windmill-components 1.87.0 → 1.89.1

package/package/stateMachine.d.ts

@@ -0,0 +1,30 @@
+import { type Readable } from 'svelte/store';
+export interface StateMachine<T extends readonly string[]> {
+    states: T;
+    currentState: T[number];
+}
+export interface StateMachineTransition<T extends readonly string[]> {
+    from?: Partial<Record<T[number], TransitionFromFunction<T>>>;
+    to?: Partial<Record<T[number], TransitionToFunction<T>>>;
+}
+type StateMachineInfo<T extends readonly string[]> = {
+    states: StateMachine<T>['states'];
+    currentState: StateMachine<T>['currentState'];
+};
+/** The return value should be a `state` that is available on the current machine. */
+export type TransitionFromFunction<T extends readonly string[]> = (info: StateMachineInfo<T> & {
+    desiredState: T[number];
+}) => T[number];
+/** Callback after the state has been changed. */
+export type TransitionToFunction<T extends readonly string[]> = (info: StateMachineInfo<T> & {
+    previousState: T[number];
+}) => T[number];
+type StateStore<T extends readonly string[]> = Readable<StateMachine<T>> & {
+    setState: (state: T[number]) => StateMachineInfo<T>;
+};
+/** **IMPORTANT:** use the `as const` syntax on the states array to get type safety.
+ * *Example: `createStateMachine(['foo', 'bar'] as const)`*
+ *
+ * Returns a new state machine with the default state set to the first element of the `states` argument. */
+export declare function createStateMachine<T extends readonly string[]>(states: T, transition?: StateMachineTransition<T>): StateStore<T>;
+export {};

package/package/stateMachine.js

@@ -0,0 +1,41 @@
+import { writable } from 'svelte/store';
+/** **IMPORTANT:** use the `as const` syntax on the states array to get type safety.
+ * *Example: `createStateMachine(['foo', 'bar'] as const)`*
+ *
+ * Returns a new state machine with the default state set to the first element of the `states` argument. */
+export function createStateMachine(states, transition = {}) {
+    const defaultValue = {
+        states,
+        currentState: states[0]
+    };
+    const defaultStore = writable(defaultValue);
+    const stateStore = {
+        subscribe: defaultStore.subscribe,
+        setState: (nextState) => {
+            defaultStore.update((prev) => {
+                const previousState = prev.currentState;
+                const beforeFunc = transition?.from && transition.from[previousState];
+                const afterFunc = transition?.to && transition.to[nextState];
+                let returnState = nextState;
+                if (beforeFunc) {
+                    returnState = beforeFunc({
+                        states,
+                        currentState: previousState,
+                        desiredState: nextState
+                    });
+                }
+                if (afterFunc) {
+                    returnState = afterFunc({
+                        states,
+                        currentState: returnState,
+                        previousState
+                    });
+                }
+                prev.currentState = returnState;
+                return prev;
+            });
+            return { states, currentState: nextState };
+        }
+    };
+    return stateStore;
+}

package/package/stores.d.ts

@@ -0,0 +1,43 @@
+import { type Readable } from 'svelte/store';
+import type { UserWorkspaceList } from './gen/models/UserWorkspaceList.js';
+import { type TokenResponse } from './gen';
+export interface UserExt {
+    email: string;
+    username: string;
+    is_admin: boolean;
+    is_super_admin: boolean;
+    operator: boolean;
+    created_at: string;
+    groups: string[];
+    pgroups: string[];
+    folders: string[];
+    folders_owners: string[];
+}
+export declare const workerTags: import("svelte/store").Writable<string[] | undefined>;
+export declare const usageStore: import("svelte/store").Writable<number>;
+export declare const runFormStore: import("svelte/store").Writable<any>;
+export declare const oauthStore: import("svelte/store").Writable<TokenResponse | undefined>;
+export declare const userStore: import("svelte/store").Writable<UserExt | undefined>;
+export declare const workspaceStore: import("svelte/store").Writable<string | undefined>;
+export declare const premiumStore: import("svelte/store").Writable<{
+    premium: boolean;
+    usage?: number | undefined;
+}>;
+export declare const starStore: import("svelte/store").Writable<number>;
+export declare const usersWorkspaceStore: import("svelte/store").Writable<UserWorkspaceList | undefined>;
+export declare const superadmin: import("svelte/store").Writable<false | String | undefined>;
+export declare const userWorkspaces: Readable<Array<{
+    id: string;
+    name: string;
+    username: string;
+}>>;
+export declare const hubScripts: import("svelte/store").Writable<{
+    path: string;
+    summary: string;
+    approved: boolean;
+    kind: string;
+    app: string;
+    ask_id: number;
+}[] | undefined>;
+export declare function switchWorkspace(workspace: string | undefined): void;
+export declare function clearStores(): void;

package/package/stores.js

@@ -0,0 +1,80 @@
+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');
+export const workerTags = writable(undefined);
+export const usageStore = writable(0);
+export const runFormStore = writable();
+export const oauthStore = writable(undefined);
+export const userStore = writable(undefined);
+export const workspaceStore = writable(persistedWorkspace ? String(persistedWorkspace) : undefined);
+export const premiumStore = writable({ premium: false });
+export const starStore = writable(1);
+export const usersWorkspaceStore = writable(undefined);
+export const superadmin = writable(undefined);
+export const userWorkspaces = derived([usersWorkspaceStore, superadmin], ([store, superadmin]) => {
+    const originalWorkspaces = store?.workspaces ?? [];
+    if (superadmin) {
+        return [
+            ...originalWorkspaces.filter((x) => x.id != 'starter' && x.id != 'admins'),
+            {
+                id: 'admins',
+                name: 'Admins',
+                username: 'superadmin'
+            }
+        ];
+    }
+    else {
+        return originalWorkspaces;
+    }
+});
+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');
+    workspaceStore.set(workspace);
+}
+export function clearStores() {
+    localStorage.removeItem('flow');
+    localStorage.removeItem('app');
+    localStorage.removeItem('workspace');
+    userStore.set(undefined);
+    workspaceStore.set(undefined);
+    usersWorkspaceStore.set(undefined);
+    superadmin.set(undefined);
+}

package/package/user.d.ts

@@ -0,0 +1,3 @@
+import { type UserExt } from './stores.js';
+export declare function refreshSuperadmin(): Promise<void>;
+export declare function getUserExt(workspace: string): Promise<UserExt | undefined>;

package/package/user.js

@@ -0,0 +1,37 @@
+import { get } from 'svelte/store';
+import { UserService } from './gen';
+import { superadmin } from './stores.js';
+import { goto } from '$app/navigation';
+export async function refreshSuperadmin() {
+    if (get(superadmin) == undefined) {
+        try {
+            const me = await UserService.globalWhoami();
+            if (me.super_admin) {
+                superadmin.set(me.email);
+            }
+            else {
+                superadmin.set(false);
+            }
+        }
+        catch {
+            superadmin.set(false);
+            goto('/user/logout');
+        }
+    }
+}
+export async function getUserExt(workspace) {
+    try {
+        const user = await UserService.whoami({ workspace });
+        return mapUserToUserExt(user);
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+function mapUserToUserExt(user) {
+    return {
+        ...user,
+        groups: user.groups,
+        pgroups: user.groups.map((x) => `g/${x}`)
+    };
+}

package/package/utils.d.ts

@@ -0,0 +1,126 @@
+import { type Flow, Script, type User } from './gen';
+import type { Schema, SupportedLanguage } from './common';
+import { type UserExt } from './stores';
+export declare function validateUsername(username: string): string;
+export declare function isToday(someDate: Date): boolean;
+export declare function daysAgo(someDate: Date): number;
+export declare function secondsAgo(date: Date): number;
+export declare function displayDaysAgo(dateString: string): string;
+export declare function displayDate(dateString: string | Date | undefined, displaySecond?: boolean): string;
+export declare function msToSec(ms: number | undefined): string;
+export declare function getToday(): Date;
+export type ToastAction = {
+    label: string;
+    callback: () => void;
+};
+export declare function sendUserToast(message: string, error?: boolean, actions?: ToastAction[]): void;
+export declare function truncateHash(hash: string): string;
+export declare function sleep(ms: number): Promise<void>;
+export declare function validatePassword(password: string): boolean;
+export declare function clickOutside(node: Node): {
+    destroy(): void;
+};
+export interface DropdownItem {
+    displayName: string;
+    eventName?: string;
+    action?: ((event?: MouseEvent) => Promise<void>) | ((event?: MouseEvent) => void);
+    href?: string;
+    separatorTop?: boolean;
+    separatorBottom?: boolean;
+    type?: 'action' | 'delete';
+    disabled?: boolean;
+    icon?: any | undefined;
+}
+export declare function emptySchema(): {
+    $schema: string | undefined;
+    properties: {};
+    required: never[];
+    type: string;
+};
+export declare function simpleSchema(): {
+    $schema: string;
+    type: string;
+    properties: {
+        name: {
+            description: string;
+            type: string;
+        };
+    };
+    required: never[];
+};
+export declare function removeItemAll<T>(arr: T[], value: T): T[];
+export declare function isOwner(path: string, user: UserExt | undefined, workspace: string | undefined): boolean;
+export declare function isObviousOwner(path: string, user?: UserExt): boolean;
+export declare function canWrite(path: string, extra_perms: Record<string, boolean>, user?: UserExt): boolean;
+export declare function emptyString(str: string | undefined | null): boolean;
+export declare function defaultIfEmptyString(str: string | undefined, dflt: string): string;
+export declare function removeKeysWithEmptyValues(obj: any): any;
+export declare function allTrue(dict: {
+    [id: string]: boolean;
+}): boolean;
+export declare function forLater(scheduledString: string): boolean;
+export declare function elapsedSinceSecs(date: string): number;
+export declare function pathIsEmpty(path: string): boolean;
+export declare function encodeState(state: any): string;
+export declare function decodeState(query: string): any;
+export declare function decodeArgs(queryArgs: string | undefined): any;
+export declare function setQuery(url: URL, key: string, value: string): Promise<void>;
+export declare function setQueryWithoutLoad(url: URL, args: {
+    key: string;
+    value: string | null | undefined;
+}[], bounceTime?: number): void;
+export declare function groupBy<T>(scripts: T[], toGroup: (t: T) => string, dflts?: string[]): [string, T[]][];
+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 mapUserToUserExt(user: User): UserExt;
+export declare function schemaToTsType(schema: Schema): string;
+export declare function schemaToObject(schema: Schema, args: Record<string, any>): Object;
+export type InputCat = 'string' | 'number' | 'boolean' | 'list' | 'resource-object' | 'enum' | 'date' | 'base64' | 'resource-string' | 'object' | 'sql' | 'yaml';
+export declare function setInputCat(type: string | undefined, format: string | undefined, itemsType: string | undefined, enum_: any, contentEncoding: string | undefined): InputCat;
+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>;
+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 formatCron(inp: string): string;
+export declare function flowToHubUrl(flow: Flow): URL;
+export declare function appToHubUrl(staticApp: any): URL;
+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 classNames(...classes: Array<string | undefined>): string;
+export declare function scriptLangToEditorLang(lang: Script.language): Script.language.GO | "typescript" | "python" | "shell";
+export declare function copyToClipboard(value?: string, sendToast?: boolean): Promise<boolean>;
+export declare function pluralize(quantity: number, word: string, customPlural?: string): string;
+export declare function capitalize(word: string): string;
+export declare function addWhitespaceBeforeCapitals(word?: string): string;
+export declare function isCloudHosted(): boolean;
+export declare function isObject(obj: any): boolean;
+export declare function debounce(func: (...args: any[]) => any, wait: number): (...args: any[]) => void;
+export declare function throttle<T>(func: (...args: any[]) => T, wait: number): (...args: any[]) => void;
+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 generateRandomString(): string;