windmill-components 1.85.0 → 1.87.0

package/dist/components/apps/editor/settingsPanel/triggerLists/TriggerBadgesList.svelte

@@ -0,0 +1,155 @@
+<script>import { Button } from '../../../../common';
+import { classNames } from '../../../../../utils';
+import { Plus, X } from 'lucide-svelte';
+import { getContext } from 'svelte';
+import { getAllRecomputeIdsForComponent } from '../../appUtils';
+export let inputDependencies = [];
+export let inlineScript;
+export let onClick = false;
+export let onLoad = false;
+export let id = undefined;
+export let recomputeOnInputChanged = false;
+const colors = {
+    green: 'text-green-800 border-green-600 bg-green-100',
+    indigo: 'text-indigo-800 border-indigo-600 bg-indigo-100',
+    blue: 'text-blue-800 border-blue-600 bg-blue-100'
+};
+let badgeClass = 'inline-flex items-center rounded-md px-2 py-0.5 text-xs font-medium border';
+const { app } = getContext('AppViewerContext');
+const { connectingInput } = getContext('AppViewerContext');
+let addingDependency = false;
+function applyConnection() {
+    if (!$connectingInput.opened && $connectingInput.input !== undefined && addingDependency) {
+        if ($connectingInput.input.connection) {
+            const x = {
+                id: $connectingInput.input.connection.componentId,
+                key: $connectingInput.input.connection.path
+            };
+            if (!inlineScript) {
+                return;
+            }
+            if (inlineScript.refreshOn?.find((y) => y.id === x.id && y.key === x.key)) {
+                return;
+            }
+            if (!inlineScript.refreshOn) {
+                inlineScript.refreshOn = [x];
+            }
+            else {
+                inlineScript.refreshOn.push(x);
+            }
+            inlineScript = JSON.parse(JSON.stringify(inlineScript));
+            addingDependency = false;
+        }
+        $connectingInput = {
+            opened: false,
+            input: undefined,
+            hoveredComponent: undefined
+        };
+        $app = $app;
+    }
+}
+$: frontendDependencies =
+    inlineScript?.language === 'frontend'
+        ? inlineScript?.refreshOn?.map((x) => `${x.id} - ${x.key}`) ?? []
+        : undefined;
+$: $connectingInput && applyConnection();
+$: recomputedBadges = getAllRecomputeIdsForComponent($app, id);
+function deleteDep(index) {
+    if (inlineScript) {
+        inlineScript.refreshOn?.splice(index, 1);
+    }
+    inlineScript = inlineScript;
+}
+</script>
+
+<div class="flex w-full flex-col items-start gap-2 mt-2 mb-1">
+	{#if recomputedBadges.length === 0 && !onLoad && !onClick && inputDependencies?.length === 0 && !frontendDependencies}
+		<p class="text-xs font-semibold text-slate-800">
+			This script has no triggers. It will never run.
+		</p>
+	{:else}
+		<div class="text-sm font-semibold text-gray-800">Triggered by</div>
+
+		{#if onLoad || onClick}
+			<div class="w-full">
+				<div class="text-xs font-semibold text-slate-800 mb-1">Events</div>
+				<div class="flex flex-row gap-2 flex-wrap">
+					{#if onLoad}
+						<span class={classNames(badgeClass, colors['green'])}>Start</span>
+						<span class={classNames(badgeClass, colors['green'])}>Refresh</span>
+					{/if}
+					{#if onClick}
+						<span class={classNames(badgeClass, colors['green'])}>Click</span>
+					{/if}
+				</div>
+			</div>
+		{/if}
+		{#if inputDependencies.length > 0 && (recomputeOnInputChanged ?? true)}
+			<div class="w-full">
+				<div class="flex justify-between items-center mb-1">
+					<div class="text-xs font-semibold text-slate-800">Change on values</div>
+				</div>
+				<div class="flex flex-row gap-2 flex-wrap">
+					{#each inputDependencies as label}
+						<span class={classNames(badgeClass, colors['blue'])}>
+							{label}
+						</span>
+					{/each}
+				</div>
+			</div>
+		{/if}
+
+		{#if recomputedBadges?.length > 0}
+			<div class="w-full">
+				<div class="text-xs font-semibold text-slate-800 mb-1">Computation of</div>
+				<div class="flex flex-row gap-2 flex-wrap">
+					{#each recomputedBadges as badge}
+						<span class={classNames(badgeClass, colors['indigo'])}>{badge}</span>
+					{/each}
+				</div>
+			</div>
+		{/if}
+	{/if}
+
+	{#if frontendDependencies && recomputeOnInputChanged}
+		<div class="w-full">
+			<div class="flex justify-between items-center">
+				<div class="text-xs font-semibold text-slate-800 mb-1">Change on values</div>
+				{#if inlineScript?.language === 'frontend'}
+					<Button
+						variant="border"
+						size="xs"
+						color="light"
+						btnClasses="!px-1 !py-0.5"
+						on:click={() => {
+							addingDependency = true
+							$connectingInput = {
+								opened: true,
+								input: undefined,
+								hoveredComponent: undefined
+							}
+						}}
+					>
+						<div class="flex flex-row gap-1 items-center">
+							Add dependency
+							<Plus size={14} />
+						</div>
+					</Button>
+				{/if}
+			</div>
+			<div class="flex flex-row gap-2 flex-wrap mt-2">
+				{#each frontendDependencies as label, index}
+					<span class={classNames(badgeClass, colors['blue'])}>
+						{label}
+						<button
+							on:click={() => deleteDep(index)}
+							class="bg-blue-300 cursor-pointer hover:bg-blue-400 ml-1 rounded-md"
+						>
+							<X size={18} class="p-0.5" />
+						</button>
+					</span>
+				{/each}
+			</div>
+		</div>
+	{/if}
+</div>

package/dist/components/apps/editor/settingsPanel/triggerLists/TriggerBadgesList.svelte.d.ts

@@ -0,0 +1,22 @@
+import { SvelteComponentTyped } from "svelte";
+import type { InlineScript } from '../../../types';
+declare const __propDef: {
+    props: {
+        inputDependencies?: string[] | undefined;
+        inlineScript: InlineScript | undefined;
+        onClick?: boolean | undefined;
+        onLoad?: boolean | undefined;
+        id?: string | undefined;
+        recomputeOnInputChanged?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type TriggerBadgesListProps = typeof __propDef.props;
+export type TriggerBadgesListEvents = typeof __propDef.events;
+export type TriggerBadgesListSlots = typeof __propDef.slots;
+export default class TriggerBadgesList extends SvelteComponentTyped<TriggerBadgesListProps, TriggerBadgesListEvents, TriggerBadgesListSlots> {
+}
+export {};

package/dist/components/apps/inputType.d.ts

@@ -0,0 +1,117 @@
+import type { ReadFileAs } from '../common/fileInput/model';
+import type { InlineScript } from './types';
+export type InputType = 'integer' | 'text' | 'textarea' | 'template' | 'number' | 'boolean' | 'select' | 'icon-select' | 'color' | 'date' | 'time' | 'datetime' | 'object' | 'array' | 'any' | 'labeledresource' | 'labeledselect' | 'tab-select';
+export type InputConnection = {
+    componentId: string;
+    path: string;
+};
+export type ConnectedInput = {
+    type: 'connected';
+    connection: InputConnection | undefined;
+};
+export type UserInput<U> = {
+    type: 'user';
+    value: U | undefined;
+};
+export type UploadInput = {
+    type: 'upload';
+    value: string;
+};
+export type EvalInput = {
+    type: 'eval';
+    expr: string;
+};
+export type RowInput = {
+    type: 'row';
+    column: string;
+};
+export type StaticInput<U> = {
+    value: U | undefined;
+    type: 'static';
+};
+export type TemplateInput = {
+    eval: string;
+    type: 'template';
+};
+export type RunnableByPath = {
+    path: string;
+    schema: any;
+    runType: 'script' | 'flow' | 'hubscript';
+    type: 'runnableByPath';
+};
+export type RunnableByName = {
+    name: string;
+    inlineScript: InlineScript | undefined;
+    type: 'runnableByName';
+};
+export type Runnable = RunnableByPath | RunnableByName | undefined;
+export type ResultInput = {
+    runnable: Runnable;
+    transformer?: InlineScript & {
+        language: 'frontend';
+    };
+    fields: Record<string, StaticAppInput | ConnectedAppInput | RowAppInput | UserAppInput>;
+    type: 'runnable';
+    value?: any;
+    doNotRecomputeOnInputChanged?: boolean;
+    recomputeOnInputChanged?: boolean;
+};
+type AppInputSpec<T extends InputType, U, V extends InputType = never> = (StaticInput<U> | ConnectedInput | UserInput<U> | RowInput | EvalInput | UploadInput | ResultInput | TemplateInput) & InputConfiguration<T, V>;
+type InputConfiguration<T extends InputType, V extends InputType> = {
+    fieldType: T;
+    subFieldType?: V;
+    format?: string | undefined;
+    fileUpload?: {
+        /** Use `*` to accept anything. */
+        accept: string;
+        /**
+         * Controls if user is allowed to select multiple files.
+         * @default false
+         */
+        multiple?: boolean;
+        /**
+         * Controls if the uploaded file(s) will be converted or not.
+         * @default false
+         */
+        convertTo?: ReadFileAs;
+    };
+};
+export type StaticOptions = {
+    selectOptions: readonly string[] | readonly {
+        value: string;
+        label: string;
+    }[];
+};
+export type AppInput = AppInputSpec<'text', string> | AppInputSpec<'textarea', string> | AppInputSpec<'template', string> | AppInputSpec<'number', number> | AppInputSpec<'boolean', boolean> | AppInputSpec<'date', string> | AppInputSpec<'time', string> | AppInputSpec<'datetime', string> | AppInputSpec<'any', any> | AppInputSpec<'object', Record<string | number, any>> | AppInputSpec<'object', string> | (AppInputSpec<'select', string> & StaticOptions) | AppInputSpec<'icon-select', string> | AppInputSpec<'color', string> | AppInputSpec<'array', string[], 'text'> | AppInputSpec<'array', string[], 'textarea'> | AppInputSpec<'array', number[], 'number'> | AppInputSpec<'array', boolean[], 'boolean'> | AppInputSpec<'array', string[], 'date'> | AppInputSpec<'array', string[], 'time'> | AppInputSpec<'array', string[], 'datetime'> | AppInputSpec<'array', object[], 'object'> | (AppInputSpec<'array', string[], 'select'> & StaticOptions) | AppInputSpec<'array', object[], 'labeledresource'> | AppInputSpec<'array', object[], 'labeledselect'> | AppInputSpec<'labeledselect', object> | AppInputSpec<'labeledresource', object> | AppInputSpec<'array', object[], 'tab-select'>;
+export type RowAppInput = Extract<AppInput, {
+    type: 'row';
+}>;
+export type StaticAppInput = Extract<AppInput, {
+    type: 'static';
+}>;
+export type ConnectedAppInput = Extract<AppInput, {
+    type: 'connected';
+}>;
+export type UserAppInput = Extract<AppInput, {
+    type: 'user';
+}>;
+export type ResultAppInput = Extract<AppInput, {
+    type: 'runnable';
+}>;
+export type EvalAppInput = Extract<AppInput, {
+    type: 'eval';
+}>;
+export type UploadAppInput = Extract<AppInput, {
+    type: 'upload';
+}>;
+export type RichAppInput = AppInput | {
+    type: 'oneOf';
+    oneOf: string[];
+    configuration: Record<string, AppInput>;
+} | {
+    type: 'group';
+    title: string;
+    configuration: Record<string, AppInput>;
+};
+export type AppInputs = Record<string, AppInput>;
+export {};

package/dist/components/apps/rx.d.ts

@@ -0,0 +1,29 @@
+import type { AppInput } from './inputType';
+import { type Writable } from 'svelte/store';
+export interface Subscriber<T> {
+    id?: string;
+    next(v: T): void;
+}
+export interface Observable<T> {
+    subscribe(x: Subscriber<T>): void;
+}
+export interface Output<T> extends Observable<T> {
+    set(x: T, force?: boolean): void;
+    peak(): T | any | undefined;
+}
+export interface Input<T> extends Subscriber<T> {
+    peak(): T | any | undefined;
+}
+export type World = {
+    outputsById: Record<string, Record<string, Output<any>>>;
+    connect: <T>(inputSpec: AppInput, next: (x: T) => void, id?: string) => Input<T>;
+    stateId: Writable<number>;
+    newOutput: <T>(id: string, name: string, previousValue: T) => Output<T>;
+};
+export declare function buildWorld(context: Record<string, any>): Writable<World>;
+export declare function buildObservableWorld(): {
+    connect: <T>(inputSpec: AppInput, next: (x: T) => void, id?: string) => Input<T>;
+    newOutput: <T_1>(id: string, name: string, state: Writable<number>, previousValue: T_1) => Output<T_1>;
+};
+export declare function cachedInput<T>(nextParan: (x: T) => void, id?: string): Input<T>;
+export declare function settableOutput<T>(state: Writable<number>, previousValue: T): Output<T>;

package/dist/components/apps/rx.js

@@ -0,0 +1,136 @@
+import { writable } from 'svelte/store';
+import { deepEqual } from 'fast-equals';
+export function buildWorld(context) {
+    const newWorld = buildObservableWorld();
+    const stateId = writable(0);
+    let writableWorld = undefined;
+    const outputsById = {
+        ctx: Object.fromEntries(Object.entries(context).map(([k, v]) => {
+            return [k, newWorld.newOutput('ctx', k, stateId, v)];
+        })),
+        state: {}
+    };
+    function newOutput(id, name, previousValue) {
+        if (outputsById[id]?.[name]) {
+            writableWorld?.update((x) => x);
+            return outputsById[id][name];
+        }
+        let o = newWorld.newOutput(id, name, stateId, previousValue);
+        if (!outputsById[id]) {
+            outputsById[id] = {};
+        }
+        outputsById[id][name] = o;
+        writableWorld?.update((x) => x);
+        return o;
+    }
+    stateId.update((x) => x + 1);
+    writableWorld = writable({
+        outputsById,
+        connect: newWorld.connect,
+        stateId,
+        newOutput
+    });
+    return writableWorld;
+}
+export function buildObservableWorld() {
+    const observables = {};
+    function connect(inputSpec, next, id) {
+        if (inputSpec.type === 'static') {
+            return {
+                id,
+                peak: () => inputSpec.value,
+                next: () => { }
+            };
+        }
+        else if (inputSpec.type === 'connected') {
+            const connection = inputSpec.connection;
+            if (!connection) {
+                return {
+                    id,
+                    peak: () => undefined,
+                    next: () => { }
+                };
+            }
+            const { componentId, path } = connection;
+            const input = cachedInput(next, `${componentId}-${path}-${id}`);
+            const [p] = path ? path.split('.')[0].split('[') : [undefined];
+            let obs = observables[`${componentId}.${p}`];
+            if (!obs) {
+                console.warn('Observable at ' + componentId + '.' + p + ' not found');
+                return {
+                    peak: () => undefined,
+                    next: () => { }
+                };
+            }
+            obs.subscribe(input);
+            input.next(obs.peak());
+            return input;
+        }
+        else if (inputSpec.type === 'user') {
+            return {
+                id,
+                peak: () => inputSpec.value,
+                next: () => { }
+            };
+        }
+        else {
+            throw Error('Unknown input type ' + inputSpec);
+        }
+    }
+    function newOutput(id, name, state, previousValue) {
+        const output = settableOutput(state, previousValue);
+        observables[`${id}.${name}`] = output;
+        return output;
+    }
+    return {
+        connect,
+        newOutput
+    };
+}
+export function cachedInput(nextParan, id) {
+    let value = undefined;
+    function peak() {
+        return value;
+    }
+    function next(x) {
+        value = x;
+        nextParan(x);
+    }
+    return {
+        id,
+        peak,
+        next
+    };
+}
+export function settableOutput(state, previousValue) {
+    let value = previousValue;
+    const subscribers = [];
+    function subscribe(x) {
+        let currentSubscriber = subscribers.findIndex((y) => y === x || (y.id && y.id === x.id));
+        if (currentSubscriber == -1) {
+            subscribers.push(x);
+        }
+        else {
+            subscribers[currentSubscriber] = x;
+        }
+        // Send the current value to the new subscriber if it already exists
+        if (value !== undefined) {
+            x.next(value);
+        }
+    }
+    function set(x, force = false) {
+        if (!deepEqual(value, x) || force) {
+            state.update((x) => x + 1);
+            value = x;
+            subscribers.forEach((x) => x.next(value));
+        }
+    }
+    function peak() {
+        return value;
+    }
+    return {
+        subscribe,
+        set,
+        peak
+    };
+}

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

@@ -0,0 +1,167 @@
+import type { Schema } from '../../common';
+import type { Preview } from '../../gen';
+import type { History } from '../../history';
+import type { Writable } from 'svelte/store';
+import type { AppComponent, components } from './editor/component/components';
+import type { AppInput, ConnectedAppInput, ConnectedInput, EvalAppInput, ResultAppInput, RowAppInput, StaticAppInput, 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 {
+    onlyStatic?: boolean;
+    tooltip?: string;
+    placeholder?: string;
+}
+export type ComponentCssProperty = {
+    class?: string;
+    style?: string;
+};
+export type ComponentCustomCSS<T extends keyof typeof components> = Partial<(typeof components)[T]['customCss']>;
+export type Configuration = StaticAppInput | ConnectedAppInput | UserAppInput | RowAppInput | EvalAppInput | UploadAppInput | ResultAppInput;
+export type StaticConfiguration = GeneralAppInput & StaticAppInput;
+export type RichConfigurationT<T> = (T & {
+    type: AppInput['type'];
+}) | {
+    type: 'oneOf';
+    selected: string;
+    tooltip?: string;
+    labels?: Record<string, string>;
+    configuration: Record<string, Record<string, T>>;
+};
+export type RichConfiguration = RichConfigurationT<Configuration>;
+export type RichConfigurations = Record<string, RichConfiguration>;
+export type StaticRichConfigurations = Record<string, RichConfigurationT<GeneralAppInput & (StaticAppInput | EvalAppInput)>>;
+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'][]>;
+};
+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;
+    refreshOn?: {
+        id: string;
+        key: string;
+    }[];
+};
+export type AppCssItemName = 'viewer' | 'grid' | AppComponent['type'];
+export type App = {
+    grid: GridItem[];
+    fullscreen: boolean;
+    norefreshbar?: boolean;
+    unusedInlineScripts: Array<{
+        name: string;
+        inlineScript: InlineScript;
+    }>;
+    hiddenInlineScripts: Array<{
+        name: string;
+        inlineScript: InlineScript | undefined;
+        fields: Record<string, StaticAppInput | ConnectedAppInput | RowAppInput | UserAppInput>;
+        autoRefresh?: boolean;
+        doNotRecomputeOnInputChanged?: boolean;
+        recomputeOnInputChanged?: boolean;
+        noBackendValue?: any;
+    }>;
+    css?: Partial<Record<AppCssItemName, Record<string, ComponentCssProperty>>>;
+    subgrids?: Record<string, GridItem[]>;
+};
+export type ConnectingInput = {
+    opened: boolean;
+    input?: ConnectedInput;
+    sourceName?: string;
+    hoveredComponent: string | undefined;
+};
+export interface CancelablePromise<T> extends Promise<T> {
+    cancel: () => void;
+}
+export type AppViewerContext = {
+    worldStore: Writable<World>;
+    app: Writable<App>;
+    summary: Writable<string>;
+    initialized: Writable<{
+        initializedComponents: string[];
+        initialized: boolean;
+    }>;
+    selectedComponent: Writable<string[] | undefined>;
+    mode: Writable<EditorMode>;
+    connectingInput: Writable<ConnectingInput>;
+    breakpoint: Writable<EditorBreakpoint>;
+    runnableComponents: Writable<Record<string, {
+        autoRefresh: boolean;
+        refreshOnStart?: boolean;
+        cb: (inlineScript?: InlineScript) => CancelablePromise<void>;
+    }>>;
+    staticExporter: Writable<Record<string, () => any>>;
+    appPath: string;
+    workspace: string;
+    onchange: (() => void) | undefined;
+    isEditor: boolean;
+    jobs: Writable<{
+        job: string;
+        component: string;
+        result?: string;
+        error?: string;
+    }[]>;
+    noBackend: boolean;
+    errorByComponent: Writable<Record<string, {
+        error: string;
+        componentId: string;
+    }>>;
+    openDebugRun: Writable<((componentID: 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;
+    }>>;
+    hoverStore: Writable<string | undefined>;
+    allIdsInPath: Writable<string[]>;
+};
+export type AppEditorContext = {
+    history: History<App> | undefined;
+    pickVariableCallback: Writable<((path: string) => void) | undefined>;
+    ontextfocus: Writable<(() => void) | undefined>;
+    selectedComponentInEditor: Writable<string | undefined>;
+    movingcomponents: Writable<string[] | undefined>;
+};
+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/dist/components/apps/utils.d.ts

@@ -0,0 +1,23 @@
+import type { Schema } from '../../common';
+import type { AppInput, InputType, ResultAppInput, StaticAppInput } from './inputType';
+import type { Output } from './rx';
+import type { App, ComponentCssProperty, GridItem, HorizontalAlignment, VerticalAlignment } from './types';
+export declare function allItems(grid: GridItem[], subgrids: Record<string, GridItem[]> | undefined): GridItem[];
+export declare function loadSchema(workspace: string, path: string, runType: 'script' | 'flow' | 'hubscript'): Promise<Schema>;
+export declare function schemaToInputsSpec(schema: Schema, defaultUserInput: boolean): Record<string, StaticAppInput>;
+export declare function accessPropertyByPath<T>(object: T, path: string): T | undefined;
+export declare function fieldTypeToTsType(inputType: InputType): string;
+export declare function isScriptByNameDefined(appInput: AppInput | undefined): boolean;
+export declare function isScriptByPathDefined(appInput: AppInput | undefined): boolean;
+export declare function clearResultAppInput(appInput: ResultAppInput): ResultAppInput;
+export declare function toStatic(app: App, staticExporter: Record<string, () => any>, summary: string): {
+    app: App;
+    summary: string;
+};
+export declare function buildExtraLib(components: Record<string, Record<string, Output<any>>>, idToExclude: string, hasRows: boolean, state: Record<string, any>, goto: boolean): string;
+export declare function getAllScriptNames(app: App): string[];
+export declare function toPascalCase(text: string): string;
+export declare function toKebabCase(text: string): string;
+export declare function concatCustomCss<T extends Record<string, ComponentCssProperty>>(appCss?: Record<string, ComponentCssProperty>, componentCss?: T): T | undefined;
+export declare function tailwindHorizontalAlignment(alignment?: HorizontalAlignment): string;
+export declare function tailwindVerticalAlignment(alignment?: VerticalAlignment): string;