windmill-components 1.87.0 → 1.89.1

package/package/utils.js

@@ -0,0 +1,653 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+import { goto } from '$app/navigation';
+import { AppService, FlowService, Script, ScriptService } from './gen';
+import { toast } from '@zerodevx/svelte-toast';
+import { hubScripts, workspaceStore } from './stores';
+import { page } from '$app/stores';
+import { get } from 'svelte/store';
+import Toast from './components/Toast.svelte';
+export function validateUsername(username) {
+    if (username != '' && !/^\w+$/.test(username)) {
+        return 'username can only contain letters and numbers';
+    }
+    else {
+        return '';
+    }
+}
+export function isToday(someDate) {
+    const today = new Date();
+    return (someDate.getDate() == today.getDate() &&
+        someDate.getMonth() == today.getMonth() &&
+        someDate.getFullYear() == today.getFullYear());
+}
+export function daysAgo(someDate) {
+    const today = new Date();
+    return Math.floor((today.getTime() - someDate.getTime()) / 86400000);
+}
+export function secondsAgo(date) {
+    return Math.max(0, Math.floor((new Date().getTime() - date.getTime()) / 1000));
+}
+export function displayDaysAgo(dateString) {
+    const date = new Date(dateString);
+    const nbSecondsAgo = secondsAgo(date);
+    if (nbSecondsAgo < 600) {
+        return `${nbSecondsAgo}s ago`;
+    }
+    else if (isToday(date)) {
+        return `today at ${date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}`;
+    }
+    else {
+        let dAgo = daysAgo(date);
+        if (dAgo == 0) {
+            return `yesterday at ${date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}`;
+        }
+        else if (dAgo > 7) {
+            return `${dAgo + 1} days ago at ${date.toLocaleTimeString([], {
+                hour: '2-digit',
+                minute: '2-digit'
+            })}`;
+        }
+        else {
+            return displayDate(dateString);
+        }
+    }
+}
+export function displayDate(dateString, displaySecond = false) {
+    const date = new Date(dateString ?? '');
+    if (date.toString() === 'Invalid Date') {
+        return '';
+    }
+    else {
+        return `${date.toLocaleTimeString([], {
+            hour: '2-digit',
+            minute: '2-digit',
+            second: displaySecond ? '2-digit' : undefined
+        })} ${date.getDate()}/${date.getMonth() + 1}`;
+    }
+}
+export function msToSec(ms) {
+    if (ms === undefined)
+        return '?';
+    return (ms / 1000).toLocaleString(undefined, { maximumFractionDigits: 3 });
+}
+export function getToday() {
+    var today = new Date();
+    return today;
+}
+export function sendUserToast(message, error = false, actions = []) {
+    toast.push({
+        component: {
+            src: Toast,
+            props: {
+                message,
+                error,
+                actions
+            },
+            sendIdTo: 'toastId'
+        },
+        dismissable: false,
+        initial: 0,
+        theme: {
+            '--toastPadding': '0',
+            '--toastMsgPadding': '0'
+        }
+    });
+}
+export function truncateHash(hash) {
+    if (hash.length >= 6) {
+        return hash.substr(hash.length - 6);
+    }
+    else {
+        return hash;
+    }
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function validatePassword(password) {
+    const re = /^(?=.*[\d])(?=.*[!@#$%^&*])[\w!@#$%^&*]{8,30}$/;
+    return re.test(password);
+}
+export function clickOutside(node) {
+    const handleClick = (event) => {
+        if (node && !node.contains(event.target) && !event.defaultPrevented) {
+            node.dispatchEvent(new CustomEvent('click_outside', { detail: event }));
+        }
+    };
+    document.addEventListener('click', handleClick, true);
+    return {
+        destroy() {
+            document.removeEventListener('click', handleClick, true);
+        }
+    };
+}
+export function emptySchema() {
+    return {
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        properties: {},
+        required: [],
+        type: 'object'
+    };
+}
+export function simpleSchema() {
+    return {
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        type: 'object',
+        properties: {
+            name: {
+                description: 'The name to hello world to',
+                type: 'string'
+            }
+        },
+        required: []
+    };
+}
+export function removeItemAll(arr, value) {
+    var i = 0;
+    while (i < arr.length) {
+        if (arr[i] === value) {
+            arr.splice(i, 1);
+        }
+        else {
+            ++i;
+        }
+    }
+    return arr;
+}
+export function isOwner(path, user, workspace) {
+    if (!user || !workspace) {
+        return false;
+    }
+    if (user.is_super_admin) {
+        return true;
+    }
+    if (workspace == 'admin') {
+        return false;
+    }
+    else if (user.is_admin) {
+        return true;
+    }
+    else if (path.startsWith('u/' + user.username + '/')) {
+        return true;
+    }
+    else if (path.startsWith('f/')) {
+        return user.folders_owners.some((x) => path.startsWith('f/' + x + '/'));
+    }
+    else {
+        return false;
+    }
+}
+export function isObviousOwner(path, user) {
+    if (!user) {
+        return false;
+    }
+    if (user.is_admin || user.is_super_admin) {
+        return true;
+    }
+    let userOwner = `u/${user.username}`;
+    if (path.startsWith(userOwner)) {
+        return true;
+    }
+    if (user.pgroups.findIndex((x) => path.startsWith(x)) != -1) {
+        return true;
+    }
+    if (user.folders.findIndex((x) => path.startsWith('f/' + x)) != -1) {
+        return true;
+    }
+    return false;
+}
+export function canWrite(path, extra_perms, user) {
+    if (user?.is_admin || user?.is_super_admin) {
+        return true;
+    }
+    let keys = Object.keys(extra_perms);
+    if (!user) {
+        return false;
+    }
+    if (isObviousOwner(path, user)) {
+        return true;
+    }
+    let userOwner = `u/${user.username}`;
+    if (keys.includes(userOwner) && extra_perms[userOwner]) {
+        return true;
+    }
+    if (user.pgroups.findIndex((x) => keys.includes(x) && extra_perms[x]) != -1) {
+        return true;
+    }
+    if (user.folders.findIndex((x) => path.startsWith('f/' + x)) != -1) {
+        return true;
+    }
+    return false;
+}
+export function emptyString(str) {
+    return str === undefined || str === null || str === '';
+}
+export function defaultIfEmptyString(str, dflt) {
+    return emptyString(str) ? dflt : str;
+}
+export function removeKeysWithEmptyValues(obj) {
+    Object.keys(obj).forEach((key) => (obj[key] === undefined ? delete obj[key] : {}));
+}
+export function allTrue(dict) {
+    return Object.values(dict).every(Boolean);
+}
+function subtractSeconds(date, seconds) {
+    date.setSeconds(date.getSeconds() - seconds);
+    return date;
+}
+export function forLater(scheduledString) {
+    return new Date() < subtractSeconds(new Date(scheduledString), 5);
+}
+export function elapsedSinceSecs(date) {
+    return Math.round((new Date().getTime() - new Date(date).getTime()) / 1000);
+}
+export function pathIsEmpty(path) {
+    return path == undefined || path.split('/')[2] == '';
+}
+export function encodeState(state) {
+    return btoa(encodeURIComponent(JSON.stringify(state)));
+}
+export function decodeState(query) {
+    return JSON.parse(decodeURIComponent(atob(query)));
+}
+export function decodeArgs(queryArgs) {
+    if (queryArgs) {
+        const parsed = decodeState(queryArgs);
+        Object.entries(parsed).forEach(([k, v]) => {
+            if (v == '<function call>') {
+                parsed[k] = undefined;
+            }
+        });
+        return parsed;
+    }
+    return {};
+}
+export async function setQuery(url, key, value) {
+    url.searchParams.set(key, value);
+    await goto(`?${url.searchParams.toString()}`);
+}
+let debounced = undefined;
+export function setQueryWithoutLoad(url, args, bounceTime) {
+    debounced && clearTimeout(debounced);
+    debounced = setTimeout(() => {
+        const nurl = new URL(url.toString());
+        for (const { key, value } of args) {
+            if (value) {
+                nurl.searchParams.set(key, value);
+            }
+            else {
+                nurl.searchParams.delete(key);
+            }
+        }
+        try {
+            history.replaceState(history.state, '', nurl.toString());
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }, bounceTime ?? 200);
+}
+export function groupBy(scripts, toGroup, dflts = []) {
+    let r = {};
+    for (const dflt of dflts) {
+        r[dflt] = [];
+    }
+    scripts.forEach((sc) => {
+        let section = toGroup(sc);
+        if (section in r) {
+            r[section].push(sc);
+        }
+        else {
+            r[section] = [sc];
+        }
+    });
+    return Object.entries(r).sort((s1, s2) => {
+        let n1 = s1[0];
+        let n2 = s2[0];
+        if (n1 > n2) {
+            return 1;
+        }
+        else if (n1 < n2) {
+            return -1;
+        }
+        else {
+            return 0;
+        }
+    });
+}
+export function removeMarkdown(text) {
+    return text.replace(/[[\*|\-|#\_]/g, '');
+}
+export function truncate(s, n, suffix = '...') {
+    if (!s) {
+        return '';
+    }
+    if (s.length <= n) {
+        return s;
+    }
+    else {
+        return s.substring(0, n) + suffix;
+    }
+}
+export function truncateRev(s, n, prefix = '...') {
+    if (!s) {
+        return prefix;
+    }
+    if (s.length <= n) {
+        return s;
+    }
+    else {
+        return prefix + s.substring(s.length - n, s.length);
+    }
+}
+export function isString(value) {
+    return typeof value === 'string' || value instanceof String;
+}
+export function mapUserToUserExt(user) {
+    return {
+        ...user,
+        groups: user.groups,
+        pgroups: user.groups.map((x) => `g/${x}`)
+    };
+}
+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;
+}
+export function setInputCat(type, format, itemsType, enum_, contentEncoding) {
+    if (type === 'number' || type === 'integer') {
+        return 'number';
+    }
+    else if (type === 'boolean') {
+        return 'boolean';
+    }
+    else if (type == 'array' && itemsType != undefined) {
+        return 'list';
+    }
+    else if (type == 'object' && format?.startsWith('resource')) {
+        return 'resource-object';
+    }
+    else if (!type || type == 'object' || type == 'array') {
+        return 'object';
+    }
+    else if (type == 'string' && enum_) {
+        return 'enum';
+    }
+    else if (type == 'string' && format == 'date-time') {
+        return 'date';
+    }
+    else if (type == 'string' && format == 'sql') {
+        return 'sql';
+    }
+    else if (type == 'string' && format == 'yaml') {
+        return 'yaml';
+    }
+    else if (type == 'string' && contentEncoding == 'base64') {
+        return 'base64';
+    }
+    else {
+        return 'string';
+    }
+}
+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');
+    }
+}
+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 formatCron(inp) {
+    // Allow for cron expressions inputted by the user to omit month and year
+    let splitted = inp.split(' ');
+    splitted = splitted.filter(String); //remove empty string elements
+    if (6 - splitted.length > 0) {
+        return splitted.concat(Array(6 - splitted.length).fill('*')).join(' ');
+    }
+    else {
+        return inp;
+    }
+}
+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;
+}
+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 function classNames(...classes) {
+    return classes.filter(Boolean).join(' ');
+}
+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 copyToClipboard(value, sendToast = true) {
+    if (!value) {
+        return false;
+    }
+    let success = false;
+    if (navigator?.clipboard) {
+        success = await navigator.clipboard
+            .writeText(value)
+            .then(() => true)
+            .catch(() => false);
+    }
+    sendToast &&
+        sendUserToast(success ? 'Copied to clipboard!' : "Couldn't copy to clipboard", !success);
+    return success;
+}
+export function pluralize(quantity, word, customPlural) {
+    if (quantity <= 1) {
+        return `${quantity} ${word}`;
+    }
+    else if (customPlural) {
+        return `${quantity} ${customPlural}}`;
+    }
+    else {
+        return `${quantity} ${word}s`;
+    }
+}
+export function capitalize(word) {
+    return word ? word.charAt(0).toUpperCase() + word.slice(1) : '';
+}
+export function addWhitespaceBeforeCapitals(word) {
+    if (!word) {
+        return '';
+    }
+    return word.replace(/([A-Z])/g, ' $1').trim();
+}
+export function isCloudHosted() {
+    return get(page)?.url?.hostname == 'app.windmill.dev';
+}
+export function isObject(obj) {
+    return typeof obj === 'object';
+}
+export function debounce(func, wait) {
+    let timeout;
+    return function (...args) {
+        // @ts-ignore
+        const context = this;
+        clearTimeout(timeout);
+        timeout = setTimeout(() => func.apply(context, args), wait);
+    };
+}
+export function throttle(func, wait) {
+    let timeout;
+    return function (...args) {
+        if (!timeout) {
+            timeout = setTimeout(() => {
+                timeout = null;
+                // @ts-ignore
+                func.apply(this, args);
+            }, wait);
+        }
+    };
+}
+export function isMac() {
+    return navigator.userAgent.indexOf('Mac OS X') !== -1;
+}
+export function getModifierKey() {
+    return isMac() ? '⌘' : 'CTRL';
+}
+export function isValidHexColor(color) {
+    return /^#(([A-F0-9]{2}){3,4}|[A-F0-9]{3})$/i.test(color);
+}
+export function sortObject(o) {
+    return Object.keys(o)
+        .sort()
+        .reduce((obj, key) => {
+        obj[key] = obj[key];
+        return obj;
+    }, {});
+}
+export function generateRandomString() {
+    let chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < 24; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}