windmill-components 1.85.0 → 1.87.0

package/utils.js

@@ -1,620 +0,0 @@
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-import { goto } from '$app/navigation';
-import { AppService, FlowService, Script, ScriptService, UserService } from './gen';
-import { toast } from '@zerodevx/svelte-toast';
-import { hubScripts, workspaceStore } from './stores';
-import { page } from '$app/stores';
-import { get } from 'svelte/store';
-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) {
-    if (error) {
-        toast.push(message, {
-            theme: {
-                '--toastBackground': '#FEE2E2',
-                '--toastBarBackground': '#FEE2E2'
-            }
-        });
-    }
-    else
-        toast.push(message);
-}
-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 async function isOwner(path, user, workspace) {
-    if (user.is_admin && (workspace == 'starter' || workspace == 'admin') && user.is_super_admin) {
-        return true;
-    }
-    else if (workspace == 'starter' || workspace == 'admin') {
-        return false;
-    }
-    else {
-        return await UserService.isOwnerOfPath({ path: path, workspace: workspace });
-    }
-}
-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) {
-    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_id=${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: ''
-        };
-    }
-    else {
-        const script = await ScriptService.getScriptByPath({
-            workspace: get(workspaceStore),
-            path: path ?? ''
-        });
-        return {
-            content: script.content,
-            language: script.language,
-            schema: script.schema,
-            description: script.description
-        };
-    }
-}
-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;
-    }, {});
-}