windmill-components 1.473.1 → 1.493.3

package/package/svelteMonarch.js

@@ -0,0 +1,303 @@
+// taken from node_modules/monaco-editor/dev/vs/basic-languages/html/html.js
+// modifications:
+// 1: replaced 'monaco_editor_core_1.' with '' (added import)
+// 2: replaced 'exports.' with 'export const '
+// 3: replaced 'text/javascript' with 'text/typescript'
+// 4: added basic moustache keywords
+import { languages } from 'monaco-editor';
+var EMPTY_ELEMENTS = [
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'keygen',
+    'link',
+    'menuitem',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr'
+];
+export const conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+    comments: {
+        blockComment: ['<!--', '-->']
+    },
+    brackets: [
+        ['<!--', '-->'],
+        ['<', '>'],
+        ['{', '}'],
+        ['(', ')']
+    ],
+    autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '<', close: '>' }
+    ],
+    onEnterRules: [
+        {
+            beforeText: new RegExp('<(?!(?:' + EMPTY_ELEMENTS.join('|') + '))([_:\\w][_:\\w-.\\d]*)([^/>]*(?!/)>)[^<]*$', 'i'),
+            afterText: /^<\/([_:\w][_:\w-.\d]*)\s*>$/i,
+            action: {
+                indentAction: languages.IndentAction.IndentOutdent
+            }
+        },
+        {
+            beforeText: new RegExp('<(?!(?:' + EMPTY_ELEMENTS.join('|') + '))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$', 'i'),
+            action: { indentAction: languages.IndentAction.Indent }
+        }
+    ],
+    folding: {
+        markers: {
+            start: new RegExp('^\\s*<!--\\s*#region\\b.*-->'),
+            end: new RegExp('^\\s*<!--\\s*#endregion\\b.*-->')
+        }
+    }
+};
+export const language = {
+    defaultToken: '',
+    tokenPostfix: '.html',
+    ignoreCase: true,
+    moustkeys: [
+        '#if',
+        '/if',
+        ':else if',
+        ':else',
+        'as',
+        '#each',
+        '/each',
+        '#await',
+        ':then',
+        ':catch',
+        '/await',
+        '#key',
+        '/key',
+        '@html',
+        '@debug'
+    ],
+    // The main tokenizer for our languages
+    tokenizer: {
+        root: [
+            [/<!DOCTYPE/, 'metatag', '@doctype'],
+            [/<!--/, 'comment', '@comment'],
+            [/{/, 'delimiter', '@curly'],
+            [/(<)((?:[\w\-]+:)?[\w\-]+)(\s*)(\/>)/, ['delimiter', 'tag', '', 'delimiter']],
+            [/(<)(script)/, ['delimiter', { token: 'tag', next: '@script' }]],
+            [/(<)(style)/, ['delimiter', { token: 'tag', next: '@style' }]],
+            [/(<)((?:[\w\-]+:)?[\w\-]+)/, ['delimiter', { token: 'tag', next: '@otherTag' }]],
+            [/(<\/)((?:[\w\-]+:)?[\w\-]+)/, ['delimiter', { token: 'tag', next: '@otherTag' }]],
+            [/</, 'delimiter'],
+            [/[^<{]+/] // text
+        ],
+        doctype: [
+            [/[^>]+/, 'metatag.content'],
+            [/>/, 'metatag', '@pop']
+        ],
+        comment: [
+            [/-->/, 'comment', '@pop'],
+            [/[^-]+/, 'comment.content'],
+            [/./, 'comment.content']
+        ],
+        curly: [
+            [/[ \t\r\n]+/],
+            [/{/, 'delimiter', '@push'],
+            [
+                /[^}\s]+/,
+                {
+                    cases: {
+                        '@moustkeys': 'keyword',
+                        '@default': 'tag'
+                    }
+                }
+            ],
+            [/}/, 'delimiter', '@pop']
+        ],
+        otherTag: [
+            [/\/?>/, 'delimiter', '@pop'],
+            [/"([^"]*)"/, 'attribute.value'],
+            [/'([^']*)'/, 'attribute.value'],
+            [/[\w\-]+/, 'attribute.name'],
+            [/=/, 'delimiter'],
+            [/[ \t\r\n]+/] // whitespace
+        ],
+        // -- BEGIN <script> tags handling
+        // After <script
+        script: [
+            [/type/, 'attribute.name', '@scriptAfterType'],
+            [/"([^"]*)"/, 'attribute.value'],
+            [/'([^']*)'/, 'attribute.value'],
+            [/[\w\-]+/, 'attribute.name'],
+            [/=/, 'delimiter'],
+            [
+                />/,
+                {
+                    token: 'delimiter',
+                    next: '@scriptEmbedded',
+                    nextEmbedded: 'text/typescript'
+                }
+            ],
+            [/[ \t\r\n]+/],
+            [/(<\/)(script\s*)(>)/, ['delimiter', 'tag', { token: 'delimiter', next: '@pop' }]]
+        ],
+        // After <script ... type
+        scriptAfterType: [
+            [/=/, 'delimiter', '@scriptAfterTypeEquals'],
+            [
+                />/,
+                {
+                    token: 'delimiter',
+                    next: '@scriptEmbedded',
+                    nextEmbedded: 'text/typescript'
+                }
+            ],
+            [/[ \t\r\n]+/],
+            [/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
+        ],
+        // After <script ... type =
+        scriptAfterTypeEquals: [
+            [
+                /"([^"]*)"/,
+                {
+                    token: 'attribute.value',
+                    switchTo: '@scriptWithCustomType.$1'
+                }
+            ],
+            [
+                /'([^']*)'/,
+                {
+                    token: 'attribute.value',
+                    switchTo: '@scriptWithCustomType.$1'
+                }
+            ],
+            [
+                />/,
+                {
+                    token: 'delimiter',
+                    next: '@scriptEmbedded',
+                    nextEmbedded: 'text/typescript'
+                }
+            ],
+            [/[ \t\r\n]+/],
+            [/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
+        ],
+        // After <script ... type = $S2
+        scriptWithCustomType: [
+            [
+                />/,
+                {
+                    token: 'delimiter',
+                    next: '@scriptEmbedded.$S2',
+                    nextEmbedded: '$S2'
+                }
+            ],
+            [/"([^"]*)"/, 'attribute.value'],
+            [/'([^']*)'/, 'attribute.value'],
+            [/[\w\-]+/, 'attribute.name'],
+            [/=/, 'delimiter'],
+            [/[ \t\r\n]+/],
+            [/<\/script\s*>/, { token: '@rematch', next: '@pop' }]
+        ],
+        scriptEmbedded: [
+            [/<\/script/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
+            [/[^<]+/, '']
+        ],
+        // -- END <script> tags handling
+        // -- BEGIN <style> tags handling
+        // After <style
+        style: [
+            [/type/, 'attribute.name', '@styleAfterType'],
+            [/"([^"]*)"/, 'attribute.value'],
+            [/'([^']*)'/, 'attribute.value'],
+            [/[\w\-]+/, 'attribute.name'],
+            [/=/, 'delimiter'],
+            [
+                />/,
+                {
+                    token: 'delimiter',
+                    next: '@styleEmbedded',
+                    nextEmbedded: 'text/css'
+                }
+            ],
+            [/[ \t\r\n]+/],
+            [/(<\/)(style\s*)(>)/, ['delimiter', 'tag', { token: 'delimiter', next: '@pop' }]]
+        ],
+        // After <style ... type
+        styleAfterType: [
+            [/=/, 'delimiter', '@styleAfterTypeEquals'],
+            [
+                />/,
+                {
+                    token: 'delimiter',
+                    next: '@styleEmbedded',
+                    nextEmbedded: 'text/css'
+                }
+            ],
+            [/[ \t\r\n]+/],
+            [/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
+        ],
+        // After <style ... type =
+        styleAfterTypeEquals: [
+            [
+                /"([^"]*)"/,
+                {
+                    token: 'attribute.value',
+                    switchTo: '@styleWithCustomType.$1'
+                }
+            ],
+            [
+                /'([^']*)'/,
+                {
+                    token: 'attribute.value',
+                    switchTo: '@styleWithCustomType.$1'
+                }
+            ],
+            [
+                />/,
+                {
+                    token: 'delimiter',
+                    next: '@styleEmbedded',
+                    nextEmbedded: 'text/css'
+                }
+            ],
+            [/[ \t\r\n]+/],
+            [/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
+        ],
+        // After <style ... type = $S2
+        styleWithCustomType: [
+            [
+                />/,
+                {
+                    token: 'delimiter',
+                    next: '@styleEmbedded.$S2',
+                    nextEmbedded: '$S2'
+                }
+            ],
+            [/"([^"]*)"/, 'attribute.value'],
+            [/'([^']*)'/, 'attribute.value'],
+            [/[\w\-]+/, 'attribute.name'],
+            [/=/, 'delimiter'],
+            [/[ \t\r\n]+/],
+            [/<\/style\s*>/, { token: '@rematch', next: '@pop' }]
+        ],
+        styleEmbedded: [
+            [/<\/style/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
+            [/[^<]+/, '']
+        ]
+        // -- END <style> tags handling
+    }
+};

package/package/toast.js

@@ -3,6 +3,9 @@ import { toast } from '@zerodevx/svelte-toast';
 export function sendUserToast(message, error = false, actions = [], errorMessage = undefined, duration = 5000) {
     toast.push({
         component: {
+            // https://github.com/zerodevx/svelte-toast/issues/115
+            // Svelte 5 changed its component type and svelte-toast is not up to date yet
+            // @ts-expect-error
             src: Toast,
             props: {
                 message,

package/package/utils.d.ts

@@ -1,12 +1,15 @@
-/// <reference types="svelte" />
-import type { UserExt } from './stores';
+import { type UserExt } from './stores';
 import { sendUserToast } from './toast';
 import type { Job, Script } from './gen';
 import type { EnumType, SchemaProperty } from './common';
 import type { Schema } from './common';
 export { sendUserToast };
 import type { AnyMeltElement } from '@melt-ui/svelte';
+import type { RunsSelectionMode } from './components/runs/RunsBatchActionsDropdown.svelte';
+import type { TriggerKind } from './components/triggers';
 export declare function isJobCancelable(j: Job): boolean;
+export declare function isJobReRunnable(j: Job): boolean;
+export declare function isJobSelectable(selectionType: RunsSelectionMode): (j: Job) => boolean;
 export declare function validateUsername(username: string): string;
 export declare function parseQueryParams(url: string | undefined): Record<string, string>;
 export declare function displayDateOnly(dateString: string | Date | undefined): string;
@@ -15,6 +18,7 @@ export declare function displayDate(dateString: string | Date | undefined, displ
 export declare function displayTime(dateString: string | Date | undefined): string;
 export declare function displaySize(sizeInBytes: number | undefined): string | undefined;
 export declare function msToSec(ms: number | undefined, maximumFractionDigits?: number): string;
+export declare function removeTriggerKindIfUnused(length: number, triggerKind: TriggerKind, usedTriggerKinds: string[]): string[];
 export declare function msToReadableTime(ms: number | undefined): string;
 export declare function getToday(): Date;
 export declare function truncateHash(hash: string): string;
@@ -66,7 +70,7 @@ export declare function groupBy<K, V>(items: V[], toGroup: (t: V) => K, toSort:
 export declare function removeMarkdown(text: string): string;
 export declare function truncate(s: string, n: number, suffix?: string): string;
 export declare function truncateRev(s: string, n: number, prefix?: string): string;
-export declare function isString(value: any): boolean;
+export declare function isString(value: any): value is string | String;
 export type InputCat = 'string' | 'email' | 'number' | 'boolean' | 'list' | 'resource-object' | 'enum' | 'date' | 'base64' | 'resource-string' | 'object' | 'sql' | 'yaml' | 'currency' | 'oneOf' | 'dynselect';
 export declare function setInputCat(type: string | undefined, format: string | undefined, itemsType: string | undefined, enum_: any, contentEncoding: string | undefined): InputCat;
 export declare function formatCron(inp: string): string;
@@ -74,6 +78,7 @@ export declare function cronV1toV2(inp: string): string;
 export declare function classNames(...classes: Array<string | undefined>): string;
 export declare function copyToClipboard(value?: string, sendToast?: boolean): Promise<boolean>;
 export declare function pluralize(quantity: number, word: string, customPlural?: string): string;
+export declare function addDeterminant(word: string): string;
 export declare function capitalize(word: string): string;
 export declare function addWhitespaceBeforeCapitals(word?: string): string;
 export declare function isObject(obj: any): obj is Record<string, any>;
@@ -83,6 +88,7 @@ export declare function isMac(): boolean;
 export declare function getModifierKey(): string;
 export declare function isValidHexColor(color: string): boolean;
 export declare function sortObject<T>(o: T & object): T;
+export declare function sortArray<T>(array: T[], compareFn?: (a: T, b: T) => number): T[];
 export declare function generateRandomString(len?: number): string;
 export declare function deepMergeWithPriority<T>(target: T, source: T): T;
 export declare function canWrite(path: string, extra_perms: Record<string, boolean>, user?: UserExt): boolean;
@@ -123,9 +129,9 @@ export declare function getSchemaFromProperties(properties: {
     [name: string]: SchemaProperty;
 }): Schema;
 export declare function validateFileExtension(ext: string): boolean;
-export declare function isFlowPreview(job_kind: Job['job_kind'] | undefined): boolean;
-export declare function isNotFlow(job_kind: Job['job_kind'] | undefined): boolean;
-export declare function isScriptPreview(job_kind: Job['job_kind'] | undefined): boolean;
+export declare function isFlowPreview(job_kind: Job['job_kind'] | undefined): job_kind is "flowpreview" | "flownode";
+export declare function isNotFlow(job_kind: Job['job_kind'] | undefined): job_kind is "script" | "preview" | "dependencies" | "flowdependencies" | "appdependencies" | "script_hub" | "identity" | "deploymentcallback" | "flowscript" | "appscript" | undefined;
+export declare function isScriptPreview(job_kind: Job['job_kind'] | undefined): job_kind is "preview" | "flowscript" | "appscript";
 export declare function conditionalMelt(node: HTMLElement, meltItem: AnyMeltElement | undefined): void | import("svelte/action").ActionReturn<undefined, Record<never, any>>;
 export type Item = {
     displayName: string;
@@ -136,4 +142,14 @@ export type Item = {
     disabled?: boolean;
     type?: 'action' | 'delete';
     hide?: boolean | undefined;
+    extra?: Snippet;
 };
+export declare function isObjectTooBig(obj: any): boolean;
+export declare function localeConcatAnd(items: string[]): string;
+export declare function formatDate(dateString: string | undefined): string;
+export declare function formatDateShort(dateString: string | undefined): string;
+export declare function toJsonStr(result: any): string;
+export declare function getOS(): "Windows" | "macOS" | "iOS" | "Android" | "Linux" | "Unknown OS";
+import { type ClassValue } from 'clsx';
+import type { Snippet } from 'svelte';
+export declare function cn(...inputs: ClassValue[]): string;

package/package/utils.js

@@ -8,11 +8,22 @@
 // import { get } from 'svelte/store'
 import { deepEqual } from 'fast-equals';
 import YAML from 'yaml';
+import {} from './stores';
 import { sendUserToast } from './toast';
 export { sendUserToast };
 export function isJobCancelable(j) {
     return j.type === 'QueuedJob' && !j.schedule_path && !j.canceled;
 }
+export function isJobReRunnable(j) {
+    return (j.job_kind === 'script' || j.job_kind === 'flow') && j.parent_job === undefined;
+}
+export function isJobSelectable(selectionType) {
+    const f = {
+        cancel: isJobCancelable,
+        're-run': isJobReRunnable
+    }[selectionType];
+    return f;
+}
 export function validateUsername(username) {
     if (username != '' && !/^[a-zA-Z]\w+$/.test(username)) {
         return 'username can only contain letters and numbers and must start with a letter';
@@ -113,6 +124,12 @@ export function msToSec(ms, maximumFractionDigits) {
         minimumFractionDigits: maximumFractionDigits
     });
 }
+export function removeTriggerKindIfUnused(length, triggerKind, usedTriggerKinds) {
+    if (length === 0 && usedTriggerKinds.includes(triggerKind)) {
+        return usedTriggerKinds.filter((kind) => kind != triggerKind);
+    }
+    return usedTriggerKinds;
+}
 export function msToReadableTime(ms) {
     if (ms === undefined)
         return '?';
@@ -196,7 +213,7 @@ export function clickOutside(node, options) {
             node.dispatchEvent(new CustomEvent(opts.customEventName, { detail: event }));
         }
     };
-    const capture = typeof options === 'boolean' ? options : options?.capture ?? true;
+    const capture = typeof options === 'boolean' ? options : (options?.capture ?? true);
     document.addEventListener('click', handleClick, capture ?? true);
     return {
         update(newOptions) {
@@ -512,6 +529,9 @@ export function pluralize(quantity, word, customPlural) {
         return `${quantity} ${word}s`;
     }
 }
+export function addDeterminant(word) {
+    return (/^[aeiou]/i.test(word) ? 'an ' : 'a ') + word;
+}
 export function capitalize(word) {
     return word ? word.charAt(0).toUpperCase() + word.slice(1) : '';
 }
@@ -562,6 +582,11 @@ export function sortObject(o) {
         return obj;
     }, {});
 }
+export function sortArray(array, compareFn) {
+    const arr = [...array];
+    arr.sort(compareFn);
+    return arr;
+}
 export function generateRandomString(len = 24) {
     let chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
     let result = '';
@@ -942,3 +967,112 @@ export function conditionalMelt(node, meltItem) {
     }
     return { destroy: () => { } };
 }
+export function isObjectTooBig(obj) {
+    const MAX_DEPTH = 10;
+    const MAX_ITEMS = 50;
+    function analyze(obj, currentDepth = 0) {
+        if (currentDepth > MAX_DEPTH) {
+            return { totalItems: 1, maxDepth: currentDepth };
+        }
+        if (typeof obj !== 'object' || obj === null) {
+            return { totalItems: 1, maxDepth: currentDepth };
+        }
+        let totalItems = 1;
+        let maxDepth = currentDepth;
+        for (const key in obj) {
+            const result = analyze(obj[key], currentDepth + 1);
+            if (result.maxDepth > MAX_DEPTH) {
+                return result;
+            }
+            totalItems += result.totalItems;
+            if (result.maxDepth > maxDepth) {
+                maxDepth = result.maxDepth;
+            }
+        }
+        return { totalItems, maxDepth };
+    }
+    const { totalItems, maxDepth } = analyze(obj);
+    return maxDepth > MAX_DEPTH || totalItems > MAX_ITEMS;
+}
+export function localeConcatAnd(items) {
+    if (!items.length)
+        return '';
+    if (items.length === 1)
+        return items[0];
+    return items.slice(0, -1).join(', ') + ' and ' + items[items.length - 1];
+}
+export function formatDate(dateString) {
+    if (!dateString)
+        return '';
+    const date = new Date(dateString);
+    return new Intl.DateTimeFormat('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit'
+    }).format(date);
+}
+export function formatDateShort(dateString) {
+    if (!dateString)
+        return '';
+    const date = new Date(dateString);
+    const now = new Date();
+    // If date is today, only show time
+    if (date.toDateString() === now.toDateString()) {
+        return new Intl.DateTimeFormat('en-US', {
+            hour: '2-digit',
+            minute: '2-digit'
+        }).format(date);
+    }
+    // If date is this year, show only month and day
+    if (date.getFullYear() === now.getFullYear()) {
+        return new Intl.DateTimeFormat('en-US', {
+            month: 'short',
+            day: 'numeric'
+        }).format(date);
+    }
+    // If date is from another year, only show the date with year
+    return new Intl.DateTimeFormat('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric'
+    }).format(date);
+}
+export function toJsonStr(result) {
+    try {
+        // console.log(result)
+        return JSON.stringify(result ?? null, null, 4) ?? 'null';
+    }
+    catch (e) {
+        return 'error stringifying object: ' + e.toString();
+    }
+}
+export function getOS() {
+    const userAgent = window.navigator.userAgent;
+    const platform = window.navigator.platform;
+    const macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'];
+    const windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'];
+    const iosPlatforms = ['iPhone', 'iPad', 'iPod'];
+    if (macosPlatforms.includes(platform)) {
+        return 'macOS';
+    }
+    else if (iosPlatforms.includes(platform)) {
+        return 'iOS';
+    }
+    else if (windowsPlatforms.includes(platform)) {
+        return 'Windows';
+    }
+    else if (/Android/.test(userAgent)) {
+        return 'Android';
+    }
+    else if (/Linux/.test(platform)) {
+        return 'Linux';
+    }
+    return 'Unknown OS';
+}
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}