windmill-components 1.309.7 → 1.352.0

package/package/components/ContextMenu.svelte.d.ts

@@ -1,28 +0,0 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        id: string;
-        contextMenu?: {
-            menuItems: {
-                label: string;
-                onClick: () => void;
-                color?: string | undefined;
-                icon: any;
-                shortcut?: string | undefined;
-                disabled?: boolean | undefined;
-            }[];
-        } | undefined;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type ContextMenuProps = typeof __propDef.props;
-export type ContextMenuEvents = typeof __propDef.events;
-export type ContextMenuSlots = typeof __propDef.slots;
-export default class ContextMenu extends SvelteComponent<ContextMenuProps, ContextMenuEvents, ContextMenuSlots> {
-}
-export {};

package/package/components/ParqetTableRenderer.svelte

@@ -1,121 +0,0 @@
-<script>import { GridApi, createGrid } from 'ag-grid-community';
-import 'ag-grid-community/styles/ag-grid.css';
-import 'ag-grid-community/styles/ag-theme-alpine.css';
-import { twMerge } from 'tailwind-merge';
-import DarkModeObserver from './DarkModeObserver.svelte';
-import { HelpersService } from '../gen';
-import { enterpriseLicense, workspaceStore } from '../stores';
-// import 'ag-grid-community/dist/styles/ag-theme-alpine-dark.css'
-let selectedRowIndex = -1;
-export let s3resource;
-let datasource = {
-    rowCount: 0,
-    getRows: async function (params) {
-        try {
-            const searchCol = params.filterModel ? Object.keys(params.filterModel)?.[0] : undefined;
-            const res = (await HelpersService.loadParquetPreview({
-                workspace: $workspaceStore,
-                path: s3resource,
-                offset: params.startRow,
-                limit: params.endRow - params.startRow,
-                sortCol: params.sortModel?.[0]?.colId,
-                sortDesc: params.sortModel?.[0]?.sort == 'desc',
-                searchCol: searchCol,
-                searchTerm: searchCol ? params.filterModel?.[searchCol]?.filter : undefined
-            }));
-            const data = [];
-            res?.columns?.forEach((c) => {
-                c.values.forEach((v, i) => {
-                    if (data[i] == undefined) {
-                        data.push({ __index: params.startRow + i });
-                    }
-                    if (!$enterpriseLicense && params.startRow + i > 3) {
-                        data[i][c.name] = 'Require EE';
-                    }
-                    else {
-                        data[i][c.name] = v;
-                    }
-                });
-            });
-            params.successCallback(data);
-        }
-        catch (e) {
-            console.error(e);
-            params.failCallback();
-        }
-    }
-};
-function toggleRow(row) {
-    if (row) {
-        let rowIndex = row.rowIndex;
-        let data = { ...row.data };
-        delete data['__index'];
-        if (selectedRowIndex !== rowIndex) {
-            selectedRowIndex = rowIndex;
-        }
-    }
-}
-function toggleRows(rows) {
-    toggleRow(rows[0]);
-}
-let eGui;
-$: eGui && mountGrid();
-async function mountGrid() {
-    if (eGui) {
-        const res = await HelpersService.loadParquetPreview({
-            workspace: $workspaceStore,
-            path: s3resource,
-            limit: 0
-        });
-        createGrid(eGui, {
-            rowModelType: 'infinite',
-            datasource,
-            // @ts-ignore
-            columnDefs: res.columns.map((c) => {
-                return {
-                    field: c.name,
-                    sortable: true,
-                    filter: true,
-                    filterParams: {
-                        filterOptions: ['contains'],
-                        maxNumConditions: 1
-                    }
-                };
-            }),
-            pagination: false,
-            // defaultColDef: {
-            // 	flex: 1
-            // },
-            suppressColumnMoveAnimation: true,
-            rowSelection: 'multiple',
-            rowMultiSelectWithClick: true,
-            suppressRowDeselection: true,
-            onSelectionChanged: (e) => {
-                onSelectionChanged(e.api);
-            },
-            getRowId: (data) => {
-                return data.data['__index'];
-            }
-        }, {});
-    }
-}
-function onSelectionChanged(api) {
-    const rows = api.getSelectedNodes();
-    if (rows != undefined) {
-        toggleRows(rows);
-    }
-}
-let darkMode = false;
-</script>
-
-<DarkModeObserver bind:darkMode />
-
-<div class={twMerge('mt-4 border shadow-sm divide-y flex flex-col h-full min-h-[600px]')}>
-	<div class="ag-theme-alpine h-full" class:ag-theme-alpine-dark={darkMode} style="height: 600px;">
-		<div bind:this={eGui} style="height:100%; " />
-	</div>
-</div>
-
-<!-- <div class="flex gap-1 absolute bottom-1 right-2 text-sm text-secondary"
-	>{firstRow}{'->'}{lastRow + 1} of {datasource?.rowCount} rows</div
-> -->

package/package/components/ParqetTableRenderer.svelte.d.ts

@@ -1,18 +0,0 @@
-import { SvelteComponent } from "svelte";
-import 'ag-grid-community/styles/ag-grid.css';
-import 'ag-grid-community/styles/ag-theme-alpine.css';
-declare const __propDef: {
-    props: {
-        s3resource: string;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type ParqetTableRendererProps = typeof __propDef.props;
-export type ParqetTableRendererEvents = typeof __propDef.events;
-export type ParqetTableRendererSlots = typeof __propDef.slots;
-export default class ParqetTableRenderer extends SvelteComponent<ParqetTableRendererProps, ParqetTableRendererEvents, ParqetTableRendererSlots> {
-}
-export {};

package/package/components/PropertyRow.svelte

@@ -1,80 +0,0 @@
-<script>import Required from './Required.svelte';
-import { createEventDispatcher } from 'svelte';
-import SchemaEditorProperty from './SchemaEditorProperty.svelte';
-import { Button } from './common';
-import { Pen, Trash } from 'lucide-svelte';
-export let displayInfo;
-export let isAnimated;
-export let lightMode;
-let depth = displayInfo.path.length;
-const required = displayInfo.isRequired;
-const dispatch = createEventDispatcher();
-function startEditArgument(name) {
-    dispatch('startEditArgument', name);
-}
-function handleDeleteArgument(argPath) {
-    dispatch('deleteArgument', argPath);
-}
-function changePosition(i, up) {
-    dispatch('changePosition', { i, up });
-}
-function getArgPath(displayInfo) {
-    return [...displayInfo.path, displayInfo.name];
-}
-const indentStyle = depth > 0 ? `margin-left :${depth}rem` : '';
-</script>
-
-<td class="font-bold">
-	<span style={indentStyle}>
-		{displayInfo.name}
-		<Required {required} class="!ml-0" />
-	</span>
-</td>
-<td>
-	<SchemaEditorProperty property={displayInfo.property} />
-</td>
-{#if !lightMode}
-	<td>{displayInfo.property.default ? JSON.stringify(displayInfo.property.default) : ''}</td>
-	<td>{displayInfo.property.description ?? ''}</td>
-{/if}
-<td />
-<td class="justify-end flex">
-	{#if depth === 0}
-		{#if displayInfo.index > 0}
-			<button
-				on:click={() => changePosition(displayInfo.index, true)}
-				class="text-lg mr-2 {isAnimated ? 'invisible' : ''}"
-			>
-				&uparrow;</button
-			>
-		{/if}
-		{#if displayInfo.index < displayInfo.propertiesNumber - 1}
-			<button
-				on:click={() => changePosition(displayInfo.index, false)}
-				class="text-lg mr-2 {isAnimated ? 'invisible' : ''}">&downarrow;</button
-			>
-		{/if}
-
-		<Button
-			color="light"
-			variant="border"
-			size={lightMode ? 'xs' : 'sm'}
-			startIcon={{ icon: Pen }}
-			on:click={() => startEditArgument(displayInfo.name)}
-			iconOnly={lightMode}
-		>
-			Edit
-		</Button>
-	{/if}
-	<Button
-		color="red"
-		variant="border"
-		btnClasses="mx-2"
-		size={lightMode ? 'xs' : 'sm'}
-		startIcon={{ icon: Trash }}
-		on:click={() => handleDeleteArgument(getArgPath(displayInfo))}
-		iconOnly={lightMode}
-	>
-		Delete
-	</Button>
-</td>

package/package/components/PropertyRow.svelte.d.ts

@@ -1,23 +0,0 @@
-import { SvelteComponent } from "svelte";
-import type { PropertyDisplayInfo } from '../common';
-declare const __propDef: {
-    props: {
-        displayInfo: PropertyDisplayInfo;
-        isAnimated: boolean;
-        lightMode: boolean;
-    };
-    events: {
-        startEditArgument: CustomEvent<any>;
-        deleteArgument: CustomEvent<any>;
-        changePosition: CustomEvent<any>;
-    } & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type PropertyRowProps = typeof __propDef.props;
-export type PropertyRowEvents = typeof __propDef.events;
-export type PropertyRowSlots = typeof __propDef.slots;
-export default class PropertyRow extends SvelteComponent<PropertyRowProps, PropertyRowEvents, PropertyRowSlots> {
-}
-export {};

package/package/components/SchemaEditor.svelte

@@ -1,344 +0,0 @@
-<script>import { modalToSchema } from '../common';
-import { emptySchema, emptyString, sendUserToast } from '../utils';
-import { Button } from './common';
-import { createEventDispatcher } from 'svelte';
-import SchemaModal, { DEFAULT_PROPERTY, schemaToModal } from './SchemaModal.svelte';
-import PropertyRow from './PropertyRow.svelte';
-import SimpleEditor from './SimpleEditor.svelte';
-import TableCustom from './TableCustom.svelte';
-import Toggle from './Toggle.svelte';
-import Tooltip from './Tooltip.svelte';
-import { flip } from 'svelte/animate';
-import Portal from 'svelte-portal';
-import { Plus } from 'lucide-svelte';
-export let isFlowInput = false;
-const dispatch = createEventDispatcher();
-export let lightMode = false;
-const moveAnimationDuration = 300;
-export let schema = emptySchema();
-if (!schema) {
-    schema = emptySchema();
-}
-let schemaModal;
-let schemaString = '';
-// Internal state: bound to args builder modal
-let argError = '';
-let editing = false;
-let oldArgName; // when editing argument and changing name
-let viewJsonSchema = false;
-let jsonEditor;
-// Binding is not enough because monaco Editor does not support two-way binding
-export function getSchema() {
-    try {
-        if (viewJsonSchema) {
-            schema = JSON.parse(schemaString);
-            return schema;
-        }
-        else {
-            schemaString = JSON.stringify(schema, null, '\t');
-            return schema;
-        }
-    }
-    catch (err) {
-        throw Error(`Error: input is not a valid schema: ${err}`);
-    }
-}
-reorder();
-function reorder() {
-    if (schema.order && Array.isArray(schema.order)) {
-        const n = {};
-        schema.order.forEach((x) => {
-            if (schema.properties && schema.properties[x] != undefined) {
-                n[x] = schema.properties[x];
-            }
-        });
-        Object.keys(schema.properties ?? {})
-            .filter((x) => !schema.order?.includes(x))
-            .forEach((x) => {
-            n[x] = schema.properties[x];
-        });
-        schema.properties = n;
-    }
-}
-function syncOrders() {
-    if (schema) {
-        schema.order = Object.keys(schema.properties ?? {});
-    }
-}
-function handleAddOrEditArgument(modalProperty) {
-    // If editing the arg's name, oldName containing the old argument name must be provided
-    argError = '';
-    modalProperty.name = modalProperty.name.trim();
-    if (modalProperty.name.length === 0) {
-        argError = 'Arguments need to have a name';
-    }
-    else if (Object.keys(schema.properties ?? {}).includes(modalProperty.name) &&
-        (!editing || (editing && oldArgName && oldArgName !== modalProperty.name))) {
-        argError = 'There is already an argument with this name';
-    }
-    else {
-        if (!schema.properties) {
-            schema.properties = {};
-        }
-        if (!schema.required) {
-            schema.required = [];
-        }
-        if (!schema.order || !Array.isArray(schema.order)) {
-            syncOrders();
-        }
-        schema.properties[modalProperty.name] = modalToSchema(modalProperty);
-        if (modalProperty.required) {
-            if (!schema.required.includes(modalProperty.name)) {
-                schema.required.push(modalProperty.name);
-            }
-        }
-        else if (schema.required.includes(modalProperty.name)) {
-            const index = schema.required.indexOf(modalProperty.name, 0);
-            if (index > -1) {
-                schema.required.splice(index, 1);
-            }
-        }
-        if (editing && oldArgName && oldArgName !== modalProperty.name) {
-            let oldPosition = schema.order.indexOf(oldArgName);
-            schema.order[oldPosition] = modalProperty.name;
-            reorder();
-            handleDeleteArgument([oldArgName]);
-        }
-        if (!schema.order?.includes(modalProperty.name)) {
-            schema.order.push(modalProperty.name);
-        }
-        modalProperty = Object.assign({}, DEFAULT_PROPERTY);
-        editing = false;
-        oldArgName = undefined;
-        schemaModal.closeDrawer();
-    }
-    schema = schema;
-    schemaString = JSON.stringify(schema, null, '\t');
-    jsonEditor?.setCode(schemaString);
-    dispatch('change', schema);
-}
-function handleStartEditEvent(event) {
-    startEditArgument(event.detail);
-}
-function startEditArgument(argName) {
-    argError = '';
-    if (Object.keys(schema.properties).includes(argName)) {
-        editing = true;
-        const modalProperty = schemaToModal(schema.properties[argName], argName, schema.required.includes(argName));
-        oldArgName = argName;
-        schemaModal.openDrawer(modalProperty);
-    }
-    else {
-        sendUserToast(`This argument does not exist and can't be edited`, true);
-    }
-}
-function handleDeleteEvent(event) {
-    handleDeleteArgument(event.detail);
-}
-function handleDeleteArgument(argPath) {
-    try {
-        let modifiedObject = schema;
-        let modifiedProperties = modifiedObject.properties;
-        let argName = argPath.pop();
-        argPath.forEach((property) => {
-            if (Object.keys(modifiedProperties).includes(property)) {
-                modifiedObject = modifiedProperties[property];
-                modifiedProperties = modifiedObject.properties;
-            }
-            else {
-                throw Error('Nested argument not found!');
-            }
-        });
-        if (Object.keys(modifiedProperties).includes(argName)) {
-            delete modifiedProperties[argName];
-            modifiedObject.required = schema.required.filter((arg) => arg !== argName);
-            if (modifiedObject.order) {
-                modifiedObject.order = modifiedObject.order.filter((arg) => arg !== argName);
-            }
-            schema = schema;
-            schemaString = JSON.stringify(schema, null, '\t');
-            dispatch('change', schema);
-        }
-        else {
-            throw Error('Argument not found!');
-        }
-        syncOrders();
-    }
-    catch (err) {
-        sendUserToast(`Could not delete argument: ${err}`, true);
-    }
-}
-function switchTab() {
-    if (viewJsonSchema) {
-        if (schemaString === '') {
-            schemaString = JSON.stringify(emptySchema(), null, 4);
-        }
-        viewJsonSchema = false;
-    }
-    else {
-        schemaString = JSON.stringify(schema, null, '\t');
-        viewJsonSchema = true;
-    }
-}
-function handleChangePositionEvent(event) {
-    changePosition(event.detail.i, event.detail.up);
-}
-function changePosition(i, up) {
-    isAnimated = true;
-    setTimeout(() => {
-        isAnimated = false;
-    }, moveAnimationDuration);
-    const entries = Object.entries(schema.properties);
-    var element = entries[i];
-    entries.splice(i, 1);
-    entries.splice(up ? i - 1 : i + 1, 0, element);
-    schema.properties = Object.fromEntries(entries);
-    syncOrders();
-}
-let isAnimated = false;
-let error = '';
-function schemaPropertiesToDisplay(schema) {
-    return propertiesToDisplay(schema.properties, schema.required, []);
-}
-function propertiesToDisplay(properties, required, path) {
-    return Object.entries(properties)
-        .map(([name, property], index) => {
-        const isRequired = required.includes(name);
-        const displayInfo = {
-            property: property,
-            name: name,
-            isRequired: isRequired,
-            path: path,
-            index: index,
-            propertiesNumber: Object.entries(properties).length
-        };
-        if (property?.type === 'object') {
-            const newPath = [...path, name];
-            return [
-                displayInfo,
-                ...propertiesToDisplay(property.properties || {}, property.required || [], newPath)
-            ];
-        }
-        else {
-            return [displayInfo];
-        }
-    })
-        .flat();
-}
-/* Small hash function to generate a unique key for each property */
-function displayInfoKey(displayInfo) {
-    const pathLengthString = displayInfo.path.length.toString();
-    return pathLengthString + [...displayInfo.path, displayInfo.name].join(pathLengthString);
-}
-</script>
-
-<div class="flex flex-col">
-	<div class="flex justify-between items-center gap-x-2">
-		<div>
-			<Button
-				variant="contained"
-				color="dark"
-				size={lightMode ? 'xs2' : 'sm'}
-				startIcon={{ icon: Plus }}
-				on:click={() => {
-					schemaModal.openDrawer(Object.assign({}, DEFAULT_PROPERTY))
-				}}
-				id="flow-editor-add-property"
-			>
-				Add Argument
-			</Button>
-		</div>
-
-		<div class="flex items-center">
-			<Toggle
-				size={lightMode ? 'xs' : 'sm'}
-				on:change={() => switchTab()}
-				options={{
-					right: 'As JSON'
-				}}
-			/>
-			<div class="ml-2">
-				<Tooltip
-					documentationLink="https://www.windmill.dev/docs/core_concepts/json_schema_and_parsing#script-parameters-to-json-schema"
-				>
-					Arguments can be edited either using the wizard, or by editing their JSON Schema.
-				</Tooltip>
-			</div>
-		</div>
-	</div>
-
-	<!--json schema or table view-->
-	<div class="h-full">
-		{#if !viewJsonSchema}
-			<div class="h-full">
-				{#if schema.properties && Object.keys(schema.properties).length > 0 && schema.required}
-					<TableCustom>
-						<tr slot="header-row">
-							<th>Name</th>
-							<th>Type</th>
-							{#if !lightMode}
-								<th>Default</th>
-								<th>Description</th>
-							{/if}
-							<th />
-						</tr>
-						<tbody slot="body">
-							{#key schema.required}
-								{#each schemaPropertiesToDisplay(schema) as displayInfo (displayInfoKey(displayInfo))}
-									<tr animate:flip={{ duration: moveAnimationDuration }}>
-										<PropertyRow
-											{displayInfo}
-											{isAnimated}
-											{lightMode}
-											on:startEditArgument={handleStartEditEvent}
-											on:deleteArgument={handleDeleteEvent}
-											on:changePosition={handleChangePositionEvent}
-										/>
-									</tr>
-								{/each}
-							{/key}
-						</tbody>
-					</TableCustom>
-				{:else}
-					<div class="text-secondary text-xs italic mt-2">This schema has no arguments.</div>
-				{/if}
-			</div>
-		{:else}
-			<div class="border rounded p-2">
-				<SimpleEditor
-					small
-					bind:this={jsonEditor}
-					fixedOverflowWidgets={false}
-					on:change={() => {
-						try {
-							schema = JSON.parse(schemaString)
-							error = ''
-						} catch (err) {
-							error = err.message
-						}
-					}}
-					bind:code={schemaString}
-					lang="json"
-					class="small-editor"
-				/>
-			</div>
-			{#if !emptyString(error)}
-				<div class="text-red-400">{error}</div>
-			{:else}
-				<div><br /></div>
-			{/if}
-		{/if}
-	</div>
-</div>
-
-<Portal>
-	<SchemaModal
-		{isFlowInput}
-		bind:this={schemaModal}
-		bind:error={argError}
-		on:save={(e) => handleAddOrEditArgument(e.detail)}
-		bind:editing
-		bind:oldArgName
-		propsNames={Object.keys(schema.properties ?? {})}
-	/>
-</Portal>

package/package/components/SchemaEditor.svelte.d.ts

@@ -1,23 +0,0 @@
-import { SvelteComponent } from "svelte";
-import { type Schema } from '../common';
-declare const __propDef: {
-    props: {
-        isFlowInput?: boolean | undefined;
-        lightMode?: boolean | undefined;
-        schema?: Schema | any;
-        getSchema?: (() => Schema) | undefined;
-    };
-    events: {
-        change: CustomEvent<any>;
-    } & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type SchemaEditorProps = typeof __propDef.props;
-export type SchemaEditorEvents = typeof __propDef.events;
-export type SchemaEditorSlots = typeof __propDef.slots;
-export default class SchemaEditor extends SvelteComponent<SchemaEditorProps, SchemaEditorEvents, SchemaEditorSlots> {
-    get getSchema(): () => Schema;
-}
-export {};