windmill-components 1.472.1 → 1.472.3

package/package/components/apps/svelte-select/lib/Select.svelte.d.ts

@@ -0,0 +1,207 @@
+/** @typedef {typeof __propDef.props}  SelectProps */
+/** @typedef {typeof __propDef.events}  SelectEvents */
+/** @typedef {typeof __propDef.slots}  SelectSlots */
+export default class Select extends SvelteComponent<{
+    value?: any;
+    input?: any;
+    id?: null | undefined;
+    name?: null | undefined;
+    disabled?: boolean | undefined;
+    label?: string | undefined;
+    filter?: typeof _filter | undefined;
+    class?: string | undefined;
+    portal?: boolean | undefined;
+    items?: any;
+    loading?: boolean | undefined;
+    required?: boolean | undefined;
+    placeholder?: string | undefined;
+    floatingConfig?: {} | undefined;
+    container?: any;
+    loadOptions?: any;
+    filterText?: string | undefined;
+    itemId?: string | undefined;
+    groupBy?: any;
+    filterSelectedItems?: boolean | undefined;
+    itemFilter?: ((label: any, filterText: any, option: any) => boolean) | undefined;
+    justValue?: any;
+    inAppEditor?: boolean | undefined;
+    getItems?: typeof _getItems | undefined;
+    focused?: boolean | undefined;
+    groupFilter?: ((groups: any) => any) | undefined;
+    groupHeaderSelectable?: boolean | undefined;
+    containerStyles?: string | undefined;
+    hasError?: boolean | undefined;
+    closeListOnChange?: boolean | undefined;
+    computeOnClick?: boolean | undefined;
+    createGroupHeaderItem?: ((groupValue: any, item: any) => {
+        [x: string]: any;
+        value: any;
+    }) | undefined;
+    getFilteredItems?: (() => any) | undefined;
+    searchable?: boolean | undefined;
+    inputStyles?: string | undefined;
+    clearable?: boolean | undefined;
+    listOpen?: boolean | undefined;
+    debounce?: ((fn: any, wait?: number) => void) | undefined;
+    debounceWait?: number | undefined;
+    hideEmptyState?: boolean | undefined;
+    inputAttributes?: {} | undefined;
+    listAutoWidth?: boolean | undefined;
+    showChevron?: boolean | undefined;
+    listOffset?: number | undefined;
+    hoverItemIndex?: number | undefined;
+    handleClear?: (() => void) | undefined;
+    ariaValues?: ((values: any) => string) | undefined;
+    ariaListOpen?: ((label: any, count: any) => string) | undefined;
+    ariaFocused?: (() => string) | undefined;
+}, {
+    mousedown: MouseEvent;
+    pointerup: PointerEvent;
+    pointerdown: PointerEvent;
+    keydown: KeyboardEvent;
+    input: CustomEvent<any>;
+    hoverItem: CustomEvent<any>;
+    filter: CustomEvent<any>;
+    focus: CustomEvent<any>;
+    blur: CustomEvent<any>;
+    clear: CustomEvent<any>;
+    change: CustomEvent<any>;
+    select: CustomEvent<any>;
+} & {
+    [evt: string]: CustomEvent<any>;
+}, {
+    'list-prepend': {};
+    list: {
+        filteredItems: any;
+    };
+    item: {
+        item: any;
+        index: any;
+    };
+    empty: {};
+    'list-append': {};
+    prepend: {};
+    selection: {
+        selection: any;
+    };
+    'loading-icon': {};
+    'clear-icon': {};
+    'chevron-icon': {
+        listOpen: boolean;
+    };
+    'input-hidden': {
+        value: any;
+    };
+    required: {
+        value: any;
+    };
+}> {
+    get getFilteredItems(): () => any;
+    get handleClear(): () => void;
+}
+export type SelectProps = typeof __propDef.props;
+export type SelectEvents = typeof __propDef.events;
+export type SelectSlots = typeof __propDef.slots;
+import _filter from './filter';
+import _getItems from './get-items';
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        value?: any;
+        input?: any;
+        id?: null | undefined;
+        name?: null | undefined;
+        disabled?: boolean | undefined;
+        label?: string | undefined;
+        filter?: typeof _filter | undefined;
+        class?: string | undefined;
+        portal?: boolean | undefined;
+        items?: any;
+        loading?: boolean | undefined;
+        required?: boolean | undefined;
+        placeholder?: string | undefined;
+        floatingConfig?: {} | undefined;
+        container?: any;
+        loadOptions?: any;
+        filterText?: string | undefined;
+        itemId?: string | undefined;
+        groupBy?: any;
+        filterSelectedItems?: boolean | undefined;
+        itemFilter?: ((label: any, filterText: any, option: any) => boolean) | undefined;
+        justValue?: any;
+        inAppEditor?: boolean | undefined;
+        getItems?: typeof _getItems | undefined;
+        focused?: boolean | undefined;
+        groupFilter?: ((groups: any) => any) | undefined;
+        groupHeaderSelectable?: boolean | undefined;
+        containerStyles?: string | undefined;
+        hasError?: boolean | undefined;
+        closeListOnChange?: boolean | undefined;
+        computeOnClick?: boolean | undefined;
+        createGroupHeaderItem?: ((groupValue: any, item: any) => {
+            [x: string]: any;
+            value: any;
+        }) | undefined;
+        getFilteredItems?: (() => any) | undefined;
+        searchable?: boolean | undefined;
+        inputStyles?: string | undefined;
+        clearable?: boolean | undefined;
+        listOpen?: boolean | undefined;
+        debounce?: ((fn: any, wait?: number) => void) | undefined;
+        debounceWait?: number | undefined;
+        hideEmptyState?: boolean | undefined;
+        inputAttributes?: {} | undefined;
+        listAutoWidth?: boolean | undefined;
+        showChevron?: boolean | undefined;
+        listOffset?: number | undefined;
+        hoverItemIndex?: number | undefined;
+        handleClear?: (() => void) | undefined;
+        ariaValues?: ((values: any) => string) | undefined;
+        ariaListOpen?: ((label: any, count: any) => string) | undefined;
+        ariaFocused?: (() => string) | undefined;
+    };
+    events: {
+        mousedown: MouseEvent;
+        pointerup: PointerEvent;
+        pointerdown: PointerEvent;
+        keydown: KeyboardEvent;
+        input: CustomEvent<any>;
+        hoverItem: CustomEvent<any>;
+        filter: CustomEvent<any>;
+        focus: CustomEvent<any>;
+        blur: CustomEvent<any>;
+        clear: CustomEvent<any>;
+        change: CustomEvent<any>;
+        select: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        'list-prepend': {};
+        list: {
+            filteredItems: any;
+        };
+        item: {
+            item: any;
+            index: any;
+        };
+        empty: {};
+        'list-append': {};
+        prepend: {};
+        selection: {
+            selection: any;
+        };
+        'loading-icon': {};
+        'clear-icon': {};
+        'chevron-icon': {
+            listOpen: boolean;
+        };
+        'input-hidden': {
+            value: any;
+        };
+        required: {
+            value: any;
+        };
+    };
+};
+export {};

package/package/components/apps/svelte-select/lib/filter.d.ts

@@ -0,0 +1,13 @@
+export default function filter({ loadOptions, filterText, items, value, itemId, groupBy, filterSelectedItems, itemFilter, convertStringItemsToObjects, filterGroupedItems, label }: {
+    loadOptions: any;
+    filterText: any;
+    items: any;
+    value: any;
+    itemId: any;
+    groupBy: any;
+    filterSelectedItems: any;
+    itemFilter: any;
+    convertStringItemsToObjects: any;
+    filterGroupedItems: any;
+    label: any;
+}): any;

package/package/components/apps/svelte-select/lib/filter.js

@@ -0,0 +1,32 @@
+export default function filter({
+	loadOptions,
+	filterText,
+	items,
+	value,
+	itemId,
+	groupBy,
+	filterSelectedItems,
+	itemFilter,
+	convertStringItemsToObjects,
+	filterGroupedItems,
+	label
+}) {
+	if (items && loadOptions) return items
+	if (!items) return []
+
+	if (items && items.length > 0 && typeof items[0] !== 'object') {
+		items = convertStringItemsToObjects(items)
+	}
+
+	let filterResults = items.filter((item) => {
+		let matchesFilter = itemFilter(item[label], filterText, item)
+
+		return matchesFilter
+	})
+
+	if (groupBy) {
+		filterResults = filterGroupedItems(filterResults)
+	}
+
+	return filterResults
+}

package/package/components/apps/svelte-select/lib/get-items.d.ts

@@ -0,0 +1,11 @@
+export default function getItems({ dispatch, loadOptions, convertStringItemsToObjects, filterText }: {
+    dispatch: any;
+    loadOptions: any;
+    convertStringItemsToObjects: any;
+    filterText: any;
+}): Promise<{
+    filteredItems: any;
+    loading: boolean;
+    focused: boolean;
+    listOpen: boolean;
+} | undefined>;

package/package/components/apps/svelte-select/lib/get-items.js

@@ -0,0 +1,30 @@
+export default async function getItems({
+	dispatch,
+	loadOptions,
+	convertStringItemsToObjects,
+	filterText
+}) {
+	let res = await loadOptions(filterText).catch((err) => {
+		console.warn('svelte-select loadOptions error :>> ', err)
+		dispatch('error', { type: 'loadOptions', details: err })
+	})
+
+	if (res && !res.cancelled) {
+		if (res) {
+			if (res && res.length > 0 && typeof res[0] !== 'object') {
+				res = convertStringItemsToObjects(res)
+			}
+
+			dispatch('loaded', { items: res })
+		} else {
+			res = []
+		}
+
+		return {
+			filteredItems: res,
+			loading: false,
+			focused: true,
+			listOpen: true
+		}
+	}
+}

package/package/components/apps/svelte-select/lib/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Select.svelte";

package/package/components/apps/svelte-select/lib/index.js

@@ -0,0 +1 @@
+export { default as default } from './Select.svelte'

package/package/components/apps/svelte-select/lib/tailwind.css

@@ -0,0 +1,130 @@
+@import 'tailwindcss/base';
+
+.svelte-select {
+    @apply border rounded box-border h-10 relative flex items-center px-4 py-0 bg-white m-0	w-full
+        hover:border-gray-400;
+}
+
+.svelte-select input {
+    @apply cursor-default border-none text-tertiary h-10 leading-10 px-4 py-0 bg-transparent text-sm absolute left-0 m-0 w-full 
+        focus:outline-none hover:border-gray-400;
+}
+
+.svelte-select.focused {
+    @apply border-blue-600;
+}
+
+.svelte-select.disabled {
+    @apply bg-gray-200 border-gray-200 text-tertiary;
+}
+
+.svelte-select.disabled input {
+    @apply placeholder:text-gray-400 placeholder:opacity-100;
+}
+
+.svelte-select .selected-item {
+    @apply leading-10 h-10 overflow-x-hidden pr-5
+        focus:outline-none;
+}
+
+.svelte-select .icons {
+    @apply absolute flex items-center right-0 translate-y-0 text-gray-200 pointer-events-none top-0 bottom-0;
+}
+
+.svelte-select .icons > * {
+    @apply transition-colors ease-in-out duration-200;
+}
+
+.svelte-select .clear-select {
+    @apply pointer-events-auto;
+}
+
+.svelte-select.focused .icons,
+.svelte-select .chevron:hover,
+.svelte-select .clear-select:hover {
+    @apply text-tertiary;
+}
+
+.svelte-select .clear-select {
+    @apply px-2 h-5 text-gray-300 flex-none w-9;
+}
+
+.svelte-select .chevron {
+    @apply flex pt-0 pr-2 pl-2 border-l-2 w-9 h-5 text-gray-300;
+}
+
+.svelte-select.multi {
+    @apply pr-9 pl-4 h-auto flex-wrap items-stretch;
+}
+
+.svelte-select.multi input {
+    @apply p-0 relative m-0;
+}
+
+.svelte-select.error {
+    @apply border-red-500 bg-white;
+}
+
+.a11y-text {
+    @apply sr-only;
+}
+
+.list {
+    @apply shadow-md rounded-sm max-h-64 overflow-y-auto bg-white border-none absolute z-10 w-full left-0 right-0;
+}
+
+.list .list-group-title {
+    @apply text-gray-400 cursor-default text-sm font-medium h-10 leading-10 px-5 overflow-ellipsis whitespace-nowrap uppercase;
+}
+
+.list .empty {
+    @apply text-center py-5 text-tertiary;
+}
+
+.item {
+    @apply cursor-default h-10 leading-10 px-5 text-gray-800 overflow-ellipsis overflow-hidden whitespace-nowrap;
+}
+
+.item.group-item {
+    @apply px-10;
+}
+
+.item:active {
+    @apply bg-blue-200;
+}
+
+.item.active {
+    @apply bg-blue-600 text-white;
+}
+
+.item.not-selectable {
+    @apply text-gray-300;
+}
+
+.item.first {
+    @apply rounded-t-sm;
+}
+
+.item.hover:not(.active) {
+    @apply bg-blue-100;
+}
+
+.multi input {
+    flex: 1 1 40px;
+}
+
+.multi-item {
+    @apply bg-gray-100 mt-1 border border-gray-200 rounded-sm h-8 leading-8 flex cursor-default pr-1 pl-1 max-w-full items-center mr-1 overflow-hidden overflow-ellipsis whitespace-nowrap;
+}
+
+.multi-item.disabled {
+    @apply hover:bg-gray-300 hover:text-tertiary;
+}
+
+.multi-item-clear {
+    @apply flex items-center justify-center w-5;
+}
+
+.list-item {
+    @apply list-none;
+}

package/package/components/apps/types.d.ts

@@ -0,0 +1,265 @@
+/// <reference types="svelte" />
+import type { Schema } from '../../common';
+import type { Policy, Preview } from '../../gen';
+import type { History } from '../../history';
+import type { Writable } from 'svelte/store';
+import type { AppComponent, PresetComponentConfig, RecomputeOthersSource, components } from './editor/component/components';
+import type { AppInput, ConnectedAppInput, ConnectedInput, EvalAppInput, EvalV2AppInput, InputConnection, ResultAppInput, RowAppInput, Runnable, StaticAppInput, TemplateV2AppInput, UploadAppInput, UserAppInput } from './inputType';
+import type { World } from './rx';
+import type { FilledItem } from './svelte-grid/types';
+export type HorizontalAlignment = 'left' | 'center' | 'right';
+export type VerticalAlignment = 'top' | 'center' | 'bottom';
+export type Aligned = {
+    horizontalAlignment: HorizontalAlignment;
+    verticalAlignment: VerticalAlignment;
+};
+export interface GeneralAppInput {
+    tooltip?: string;
+    placeholder?: string;
+    customTitle?: string;
+}
+export type ComponentCssProperty = {
+    class?: string;
+    style?: string;
+    evalClass?: RichConfiguration;
+};
+export type ComponentCustomCSS<T extends keyof typeof components> = Partial<(typeof components)[T]['customCss']>;
+export type Configuration = StaticAppInput | ConnectedAppInput | UserAppInput | RowAppInput | EvalAppInput | EvalV2AppInput | UploadAppInput | ResultAppInput | TemplateV2AppInput;
+export type StaticConfiguration = GeneralAppInput & StaticAppInput;
+export type OneOfRichConfiguration<T> = {
+    type: 'oneOf';
+    selected: string;
+    tooltip?: string;
+    labels?: Record<string, string>;
+    configuration: Record<string, Record<string, T>>;
+};
+export type OneOfConfiguration = OneOfRichConfiguration<GeneralAppInput & (StaticAppInput | EvalAppInput | EvalV2AppInput)>;
+export type RichConfigurationT<T> = (T & {
+    type: AppInput['type'];
+}) | OneOfRichConfiguration<T>;
+export type RichConfiguration = RichConfigurationT<Configuration>;
+export type RichConfigurations = Record<string, RichConfiguration>;
+export type StaticRichConfigurations = Record<string, RichConfigurationT<GeneralAppInput & (StaticAppInput | EvalAppInput | EvalV2AppInput)>>;
+export interface BaseAppComponent extends Partial<Aligned> {
+    id: ComponentID;
+    componentInput: AppInput | undefined;
+    configuration: RichConfigurations;
+    customCss?: Record<string, ComponentCssProperty>;
+    numberOfSubgrids?: number;
+}
+export type ComponentSet = {
+    title: string;
+    components: Readonly<AppComponent['type'][]>;
+    presets?: Readonly<PresetComponentConfig['type'][]> | undefined;
+};
+type SectionID = string;
+export type AppSection = {
+    components: AppComponent[];
+    id: SectionID;
+};
+export type GridItem = FilledItem<AppComponent>;
+export type InlineScript = {
+    content: string;
+    language: Preview['language'] | 'frontend';
+    path?: string;
+    schema?: Schema;
+    lock?: string;
+    cache_ttl?: number;
+    refreshOn?: {
+        id: string;
+        key: string;
+    }[];
+    suggestedRefreshOn?: {
+        id: string;
+        key: string;
+    }[];
+    id?: number;
+};
+export type AppCssItemName = 'viewer' | 'grid' | AppComponent['type'];
+export type HiddenRunnable = {
+    name: string;
+    transformer?: InlineScript & {
+        language: 'frontend';
+    };
+    fields: Record<string, StaticAppInput | ConnectedAppInput | RowAppInput | UserAppInput>;
+    autoRefresh?: boolean;
+    doNotRecomputeOnInputChanged?: boolean;
+    recomputeOnInputChanged?: boolean;
+    noBackendValue?: any;
+    hidden?: boolean;
+} & Runnable & RecomputeOthersSource;
+export type AppTheme = {
+    type: 'path';
+    path: string;
+} | {
+    type: 'inlined';
+    css: string;
+};
+export type App = {
+    grid: GridItem[];
+    darkMode?: boolean;
+    fullscreen: boolean;
+    norefreshbar?: boolean;
+    unusedInlineScripts: Array<{
+        name: string;
+        inlineScript: InlineScript;
+    }>;
+    hiddenInlineScripts: Array<HiddenRunnable>;
+    css?: Partial<Record<AppCssItemName, Record<string, ComponentCssProperty>>>;
+    subgrids?: Record<string, GridItem[]>;
+    theme: AppTheme | undefined;
+    lazyInitRequire?: string[] | undefined;
+    hideLegacyTopBar?: boolean | undefined;
+    mobileViewOnSmallerScreens?: boolean | undefined;
+    version?: number;
+};
+export type ConnectingInput = {
+    opened: boolean;
+    input?: ConnectedInput;
+    sourceName?: string;
+    hoveredComponent: string | undefined;
+    onConnect?: ((connection: InputConnection) => void) | undefined;
+};
+export interface CancelablePromise<T> extends Promise<T> {
+    cancel: () => void;
+}
+export type ListContext = Writable<{
+    index: number;
+    value: any;
+    disabled: boolean;
+}>;
+export type ListInputs = {
+    set: (id: string, value: any) => void;
+    remove: (id: string) => void;
+};
+export type GroupContext = {
+    id: string;
+    context: Writable<Record<string, any>>;
+};
+export type AppViewerContext = {
+    worldStore: Writable<World>;
+    app: Writable<App>;
+    summary: Writable<string>;
+    initialized: Writable<{
+        initializedComponents: string[];
+        initialized: boolean;
+        runnableInitialized: Record<string, any>;
+    }>;
+    selectedComponent: Writable<string[] | undefined>;
+    mode: Writable<EditorMode>;
+    connectingInput: Writable<ConnectingInput>;
+    breakpoint: Writable<EditorBreakpoint>;
+    bgRuns: Writable<string[]>;
+    runnableComponents: Writable<Record<string, {
+        autoRefresh: boolean;
+        refreshOnStart?: boolean;
+        cb: ((inlineScript?: InlineScript, setRunnableJob?: boolean) => CancelablePromise<void>)[];
+    }>>;
+    staticExporter: Writable<Record<string, () => any>>;
+    appPath: Writable<string>;
+    workspace: string;
+    onchange: (() => void) | undefined;
+    isEditor: boolean;
+    jobs: Writable<string[]>;
+    jobsById: Writable<Record<string, {
+        job: string;
+        component: string;
+        result?: string;
+        error?: any;
+        transformer?: {
+            result?: string;
+            error?: string;
+        };
+        created_at?: number;
+        started_at?: number;
+        duration_ms?: number;
+    }>>;
+    noBackend: boolean;
+    errorByComponent: Writable<Record<string, {
+        id?: string;
+        error: string;
+    }>>;
+    openDebugRun: Writable<((jobID: string) => void) | undefined>;
+    focusedGrid: Writable<FocusedGrid | undefined>;
+    stateId: Writable<number>;
+    parentWidth: Writable<number>;
+    state: Writable<Record<string, any>>;
+    componentControl: Writable<Record<string, {
+        left?: () => boolean;
+        right?: (skipTableActions?: boolean | undefined) => string | boolean;
+        setTab?: (index: number) => void;
+        agGrid?: {
+            api: any;
+            columnApi: any;
+        };
+        setCode?: (value: string) => void;
+        onDelete?: () => void;
+        setValue?: (value: any) => void;
+        setSelectedIndex?: (index: number) => void;
+        openModal?: () => void;
+        closeModal?: () => void;
+        open?: () => void;
+        close?: () => void;
+        validate?: (key: string) => void;
+        invalidate?: (key: string, error: string) => void;
+        validateAll?: () => void;
+        clearFiles?: () => void;
+        showToast?: (message: string, error?: boolean) => void;
+        recompute?: () => void;
+        askNewResource?: () => void;
+        setGroupValue?: (key: string, value: any) => void;
+    }>>;
+    hoverStore: Writable<string | undefined>;
+    allIdsInPath: Writable<string[]>;
+    darkMode: Writable<boolean>;
+    cssEditorOpen: Writable<boolean>;
+    previewTheme: Writable<string | undefined>;
+    debuggingComponents: Writable<Record<string, number>>;
+    replaceStateFn?: ((url: string) => void) | undefined;
+    gotoFn?: ((url: string, opt?: Record<string, any> | undefined) => void) | undefined;
+    policy: Policy;
+    recomputeAllContext: Writable<{
+        onClick?: () => void;
+        componentNumber?: number | undefined;
+        interval?: number | undefined;
+        refreshing?: string[] | undefined;
+        setInter?: (interval: number) => void | undefined;
+        progress?: number | undefined;
+        loading?: boolean | undefined;
+    }>;
+    panzoomActive: Writable<boolean>;
+};
+export type AppEditorContext = {
+    yTop: Writable<number>;
+    runnableJobEditorPanel: Writable<{
+        focused: boolean;
+        jobs: Record<string, string>;
+        frontendJobs: Record<string, any>;
+        width: number;
+    }>;
+    evalPreview: Writable<Record<string, any>>;
+    componentActive: Writable<boolean>;
+    dndItem: Writable<Record<string, (x: number, y: number, topY: number) => void>>;
+    refreshComponents: Writable<(() => void) | undefined>;
+    history: History<App> | undefined;
+    pickVariableCallback: Writable<((path: string) => void) | undefined>;
+    selectedComponentInEditor: Writable<string | undefined>;
+    movingcomponents: Writable<string[] | undefined>;
+    jobsDrawerOpen: Writable<boolean>;
+    scale: Writable<number>;
+    stylePanel: () => any;
+};
+export type FocusedGrid = {
+    parentComponentId: string;
+    subGridIndex: number;
+};
+export type EditorMode = 'dnd' | 'preview';
+export type EditorBreakpoint = 'sm' | 'lg';
+export declare const IS_APP_PUBLIC_CONTEXT_KEY: "isAppPublicContext";
+type ComponentID = string;
+export type ContextPanelContext = {
+    search: Writable<string>;
+    manuallyOpened: Writable<Record<string, boolean>>;
+    hasResult: Writable<Record<string, boolean>>;
+};
+export {};

package/package/components/apps/types.js

@@ -0,0 +1 @@
+export const IS_APP_PUBLIC_CONTEXT_KEY = 'isAppPublicContext';