@parallelworks/ui 0.1.0 → 0.2.0

package/dist/components/SwitchToggle.d.ts

@@ -0,0 +1,12 @@
+interface IToggleProps {
+    onChange: (value: boolean) => void;
+    value?: boolean;
+    /** Display label for the on/off positions; defaults to Yes/No. */
+    yesLabel?: string;
+    noLabel?: string;
+    disabled?: boolean;
+    datatip?: string;
+    invalid?: boolean;
+}
+declare function SwitchToggle({ onChange, value, yesLabel, noLabel, disabled, datatip, invalid, }: IToggleProps): import("react").JSX.Element;
+export default SwitchToggle;

package/dist/components/SwitchToggleSmall.d.ts

@@ -0,0 +1,6 @@
+import type React from 'react';
+interface SwitchToggleSmallProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'value'> {
+    value?: boolean;
+}
+export default function SwitchToggleSmall({ value, disabled, className, ...buttonProps }: SwitchToggleSmallProps): React.JSX.Element;
+export {};

package/dist/components/dropdownUtils.d.ts

@@ -0,0 +1,18 @@
+import type React from 'react';
+export interface IOptions<T = unknown> {
+    label: string;
+    value: T;
+    secondaryValue?: unknown;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+    description?: string;
+}
+export interface ICategory<T = unknown> {
+    category?: string;
+    options: IOptions<T>[];
+}
+export declare function isCategory<T>(option: ICategory<T> | IOptions<T> | string): option is ICategory<T>;
+export declare function isOption<T>(option: ICategory<T> | IOptions<T> | string): option is IOptions<T>;
+export declare function flattenOptions<T>(options: (ICategory<T> | IOptions<T> | string)[]): (IOptions<T> | ICategory<T>)[];
+export declare function filterOption<T>(option: IOptions<T>, query: string): boolean;
+export declare function DropdownCaret(): React.JSX.Element;

package/dist/editor/Editor.d.ts

@@ -0,0 +1,2 @@
+import type { IEditorProps } from './Monaco.js';
+export default function Editor({ ...props }: IEditorProps): import("react").JSX.Element;

package/dist/editor/EditorField.d.ts

@@ -0,0 +1,11 @@
+import type { FieldComponentProps } from '../form/types/fieldComponentTypes.js';
+import type { BaseField } from '../form/types/fieldTypes.js';
+export interface IEditorField extends BaseField {
+    type: 'editor';
+    default?: string;
+    options?: {
+        language?: string;
+        theme?: string;
+    };
+}
+export default function EditorField(props: FieldComponentProps<IEditorField>): import("react").JSX.Element;

package/dist/editor/FormCodePanel.d.ts

@@ -0,0 +1,8 @@
+declare function FormCodePanel({ formJSON, data, mutate, height, disabled, }: {
+    formJSON: Record<string, any>;
+    data: Record<string, any>;
+    mutate: any;
+    height?: string;
+    disabled?: boolean;
+}): import("react").JSX.Element;
+export default FormCodePanel;

package/dist/editor/Monaco.d.ts

@@ -0,0 +1,31 @@
+import * as monaco from 'monaco-editor';
+export interface EditorMarketplaceItem {
+    readonly slug?: string;
+    readonly name?: string | null;
+    readonly description?: string | null;
+    readonly type?: string | null;
+    readonly subtype?: string | null;
+    readonly versions?: readonly string[] | null;
+}
+export interface EditorWorkflowItem {
+    readonly name?: string;
+    readonly displayName?: string | null;
+    readonly description?: string | null;
+    readonly type?: string | null;
+}
+type MarketplaceItem = EditorMarketplaceItem;
+type WorkflowItem = EditorWorkflowItem;
+export type ISchemaError = monaco.editor.IMarker;
+export interface IEditorProps extends monaco.editor.IStandaloneEditorConstructionOptions {
+    className?: string;
+    disabled?: boolean;
+    onChange?: (value: string) => void;
+    onValidate?: (errors: any[]) => void;
+    width?: string | number;
+    height?: string | number;
+    path?: 'file:///workflow.yaml' | string;
+    marketplaceItems?: MarketplaceItem[];
+    workflows?: WorkflowItem[];
+}
+export default function MonacoEditor({ className, disabled, onChange, onValidate, width, height, path, marketplaceItems, workflows, ...options }: IEditorProps): import("react").JSX.Element;
+export {};

package/dist/editor/index.d.ts

@@ -0,0 +1,6 @@
+export { default as Editor } from './Editor.js';
+export { default as EditorField, type IEditorField } from './EditorField.js';
+export { default as FormCodePanel } from './FormCodePanel.js';
+export type { EditorMarketplaceItem, EditorWorkflowItem, IEditorProps, ISchemaError, } from './Monaco.js';
+export { defineEditorThemes, getThemeName } from './themes.js';
+export { setupMonacoWorkers } from './workers.js';

package/dist/editor/index.js

@@ -0,0 +1,219 @@
+import { CheckIcon, CopyIcon, EyeIcon, EyeOffIcon } from "../icons.js";
+import { o as useStrings, r as useNotify } from "../chunks/Provider-C2VtPnh5.js";
+import { t as Loader } from "../chunks/Loader-DQiZ75fa.js";
+import { t as SwitchToggleSmall } from "../chunks/SwitchToggleSmall-FcsaYSTs.js";
+import { c as FieldWrapper, n as flattenGroups, r as impureSetValueFromPath } from "../chunks/lib-DTgL8klR.js";
+import { n as defineEditorThemes, r as getThemeName, t as setupMonacoWorkers } from "../chunks/workers-Cjfjb8E7.js";
+import cx from "classnames";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Suspense, lazy, useMemo, useRef, useState } from "react";
+import { convertToDynamicForm, parseStringsOfObj, parseStringsOfObjReady } from "@parallelworks/workflow-parser";
+import { useField, useFormikContext } from "formik";
+//#region src/editor/Editor.tsx
+var MonacoEditor = lazy(() => import("../chunks/Monaco-CP_cL9gp.js"));
+function Editor({ ...props }) {
+	return /* @__PURE__ */ jsx(Suspense, {
+		fallback: /* @__PURE__ */ jsx(Loader, { text: "Loading editor..." }),
+		children: /* @__PURE__ */ jsx(MonacoEditor, { ...props })
+	});
+}
+//#endregion
+//#region src/editor/EditorField.tsx
+function hasResetKeys(obj) {
+	return obj.editorKeyPostfix !== void 0;
+}
+function EditorField(props) {
+	const { field, label, labelPosition, disabled, onChange, tooltipComponent, spaceCompact, setFormDirty } = props;
+	const [fieldState] = useField(field.name);
+	const { setFieldValue, setFieldTouched, values } = useFormikContext();
+	const debounceRef = useRef(null);
+	const touchedRef = useRef(false);
+	const handleChange = (val) => {
+		touchedRef.current = true;
+		if (debounceRef.current) clearTimeout(debounceRef.current);
+		debounceRef.current = setTimeout(() => {
+			if (onChange) onChange(val);
+			setFieldTouched(field.name, true);
+			setFieldValue(field.name, val);
+			setFormDirty(true);
+		}, 500);
+	};
+	let editorKeyPostfix = "";
+	if (hasResetKeys(values)) editorKeyPostfix = values.editorKeyPostfix;
+	const postfixKey = useMemo(() => {
+		const randomKey = Math.random().toString(36).substring(7);
+		return editorKeyPostfix || randomKey;
+	}, [editorKeyPostfix]);
+	const value = fieldState.value;
+	return /* @__PURE__ */ jsx(FieldWrapper, {
+		optional: field.optional,
+		label,
+		tooltipComponent,
+		labelPosition,
+		spaceCompact,
+		children: /* @__PURE__ */ jsx(Editor, {
+			height: "200px",
+			path: field.name,
+			value: touchedRef.current ? void 0 : value,
+			className: cx("bg-(--theme-input-bg) w-11 border focus:border rounded text-[10px] leading-4 pl-[6px]", disabled && "opacity-75"),
+			readOnly: disabled,
+			onChange: handleChange,
+			language: field.options?.language || "shell"
+		}, field.name + postfixKey)
+	});
+}
+//#endregion
+//#region src/editor/FormCodePanel.tsx
+var shouldIgnoreField = (fieldSchema, inputs, arrayIndex) => {
+	if (!fieldSchema?.ignore || !fieldSchema?.hidden) return false;
+	if (!parseStringsOfObjReady) return false;
+	return parseStringsOfObj({
+		inputs,
+		obj: convertToDynamicForm(fieldSchema),
+		index: arrayIndex ?? -1
+	}).hidden === true;
+};
+var filterFields = (formJSON, data, prefix, rootData, arrayIndex) => {
+	const filteredFields = [];
+	return {
+		filteredFields,
+		filtered: Object.keys(data).reduce((acc, key) => {
+			if (data[key] !== null && Array.isArray(data[key])) {
+				acc[key] = [];
+				if (!formJSON[key]) return acc;
+				for (let i = 0; i < data[key].length; i++) {
+					let filteredFieldsNested = [];
+					let filteredNested = {};
+					if (typeof data[key][i] === "object") {
+						const result = filterFields(formJSON[key].options, data[key][i], key + `[${i}].`, rootData || data, i);
+						filteredNested = result.filtered;
+						filteredFieldsNested = result.filteredFields;
+					} else filteredNested = data[key][i];
+					filteredFields.push(...filteredFieldsNested);
+					acc[key][i] = filteredNested;
+				}
+				return acc;
+			}
+			if (data[key] !== null && formJSON && formJSON[key] && typeof data[key] === "object") {
+				const { filteredFields: filteredFieldsNested, filtered: filteredNested } = filterFields(formJSON[key], data[key], key + ".", rootData || data, arrayIndex);
+				filteredFields.push(...filteredFieldsNested);
+				acc[key] = filteredNested;
+				return acc;
+			}
+			if (formJSON?.[key]?.sensitive) {
+				const name = prefix ? prefix + key : key;
+				filteredFields.push({
+					key: name,
+					value: data[key]
+				});
+				return acc;
+			}
+			const contextData = rootData || data;
+			if (formJSON && shouldIgnoreField(formJSON[key], contextData, arrayIndex)) return acc;
+			acc[key] = data[key];
+			return acc;
+		}, {})
+	};
+};
+var populateFiltered = (filteredFields, data) => {
+	filteredFields.forEach((element) => {
+		impureSetValueFromPath(data, element.key, element.value);
+	});
+	return data;
+};
+function FormCodePanel({ formJSON, data, mutate, height = "600px", disabled = false }) {
+	const notify = useNotify();
+	const { common: t } = useStrings();
+	const [jsonHasErrors, setJsonHasErrors] = useState(false);
+	const [showHidden, setShowHidden] = useState(false);
+	const [copied, setCopied] = useState(false);
+	const copyResetRef = useRef(void 0);
+	const isValidJson = (errors) => {
+		setJsonHasErrors(errors.length > 0);
+	};
+	const { filteredFields, filtered } = filterFields(flattenGroups(formJSON), data || {});
+	const hasHiddenFields = filteredFields.length > 0;
+	const displayObj = showHidden && hasHiddenFields ? populateFiltered(filteredFields, structuredClone(filtered)) : filtered;
+	const showHiddenRef = useRef(showHidden);
+	showHiddenRef.current = showHidden;
+	const filteredFieldsRef = useRef(filteredFields);
+	filteredFieldsRef.current = filteredFields;
+	const json = JSON.stringify(displayObj, null, 2);
+	const handleCopy = async () => {
+		try {
+			await navigator.clipboard.writeText(json);
+			setCopied(true);
+			clearTimeout(copyResetRef.current);
+			copyResetRef.current = setTimeout(() => setCopied(false), 2e3);
+		} catch {
+			notify.error(t.copyFailed);
+		}
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		style: { height },
+		className: "flex w-full flex-col gap-2",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: cx("flex min-h-0 flex-1 flex-col overflow-hidden rounded-md border", jsonHasErrors ? "border-red-500" : "border-(--theme-border)"),
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: "bg-(--theme-muted-panel-bg) text-(--theme-muted-panel-color) flex shrink-0 items-center gap-3 border-b border-(--theme-border) px-3 py-2",
+				children: [hasHiddenFields && /* @__PURE__ */ jsxs("label", {
+					title: t.showHiddenFieldsHint,
+					className: "flex cursor-pointer select-none items-center gap-2 text-sm text-(--theme-app)",
+					children: [/* @__PURE__ */ jsx(SwitchToggleSmall, {
+						value: showHidden,
+						"aria-label": t.showHiddenFields,
+						onClick: () => setShowHidden((prev) => !prev)
+					}), /* @__PURE__ */ jsxs("span", {
+						className: "flex items-center gap-1.5",
+						children: [showHidden ? /* @__PURE__ */ jsx(EyeIcon, {}) : /* @__PURE__ */ jsx(EyeOffIcon, {}), t.showHiddenFields]
+					})]
+				}), /* @__PURE__ */ jsxs("button", {
+					type: "button",
+					onClick: handleCopy,
+					"aria-label": copied ? t.copied : t.copy,
+					className: "ml-auto flex shrink-0 items-center gap-1.5 rounded-md border border-(--theme-border) px-2.5 py-1.5 text-sm text-(--theme-app) transition-colors duration-150 hover:bg-(--theme-hover) focus:outline-none focus-visible:ring-2 focus-visible:ring-(--theme-link)",
+					children: [copied ? /* @__PURE__ */ jsx(CheckIcon, { className: "text-green-500" }) : /* @__PURE__ */ jsx(CopyIcon, { className: "text-(--theme-muted-text-color)" }), copied ? t.copied : t.copy]
+				})]
+			}), /* @__PURE__ */ jsx("div", {
+				className: "min-h-0 flex-1",
+				children: /* @__PURE__ */ jsx(Editor, {
+					height: "100%",
+					value: json,
+					onValidate: isValidJson,
+					className: "!rounded-none !border-0",
+					minimap: { enabled: false },
+					scrollBeyondLastLine: false,
+					overviewRulerLanes: 0,
+					overviewRulerBorder: false,
+					lineNumbersMinChars: 3,
+					lineDecorationsWidth: 8,
+					renderLineHighlight: "none",
+					padding: {
+						top: 12,
+						bottom: 12
+					},
+					fontSize: 13,
+					scrollbar: {
+						verticalScrollbarSize: 10,
+						horizontalScrollbarSize: 10
+					},
+					onChange: (e) => {
+						try {
+							const parsed = JSON.parse(e);
+							mutate(showHiddenRef.current ? parsed : populateFiltered(filteredFieldsRef.current, parsed));
+						} catch {
+							console.log("JSON.parse error in slurm editor");
+						}
+					},
+					language: "json",
+					disabled
+				})
+			})]
+		}), jsonHasErrors && /* @__PURE__ */ jsx("p", {
+			className: "shrink-0 text-sm text-red-500",
+			children: t.jsonHasErrors
+		})]
+	});
+}
+//#endregion
+export { Editor, EditorField, FormCodePanel, defineEditorThemes, getThemeName, setupMonacoWorkers };

package/dist/editor/themes.d.ts

@@ -0,0 +1,4 @@
+import type * as monaco from 'monaco-editor';
+export declare function expandShorthandHex(color: string): string;
+export declare function defineEditorThemes(monacoEditor: typeof monaco.editor): void;
+export declare function getThemeName(isDark: boolean, disabled?: boolean): string;

package/dist/editor/workers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Points window.MonacoEnvironment at the bundled workers. Idempotent, and a
+ * host that already configured its own MonacoEnvironment wins — the editor
+ * calls this on first load only when nothing is configured.
+ */
+export declare function setupMonacoWorkers(): void;

package/dist/form/FieldWrapper.d.ts

@@ -0,0 +1,10 @@
+import type React from 'react';
+export declare function FieldWrapper({ label, tooltipComponent, description, labelPosition, spaceCompact, optional, children, }: {
+    label: string;
+    tooltipComponent?: React.ReactNode;
+    description?: string | undefined;
+    labelPosition?: 'left' | 'top' | undefined;
+    spaceCompact?: boolean | undefined;
+    optional?: boolean | undefined;
+    children: React.ReactNode;
+}): React.JSX.Element;

package/dist/form/Fields/BooleanField.d.ts

@@ -0,0 +1,12 @@
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+export interface IBooleanField extends BaseField {
+    type: 'boolean';
+    default?: boolean;
+    options?: {
+        onOption?: boolean | string;
+        offOption?: boolean | string;
+    };
+    disabled_message?: string;
+}
+export default function BooleanField(props: FieldComponentProps<IBooleanField>): import("react").JSX.Element;

package/dist/form/Fields/BucketReadOnlyField.d.ts

@@ -0,0 +1,7 @@
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+interface BucketReadOnlyField extends BaseField {
+    type: 'bucket-read-only';
+}
+export default function BucketReadOnlyField({ field, disabled, missing, labelPosition, setFormDirty, }: FieldComponentProps<BucketReadOnlyField>): import("react").JSX.Element;
+export {};

package/dist/form/Fields/CheckboxGroupField.d.ts

@@ -0,0 +1,18 @@
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+export interface ICheckboxGroupField extends BaseField {
+    type: 'checkbox-group';
+    options?: Array<{
+        label: string;
+        value: string;
+        description?: string;
+    }>;
+    /**
+     * Maps a value to the values it forces on. While the key is selected, each
+     * listed value is checked and locked (disabled) to show the implication.
+     * Deselecting the key clears the implied values unless the user had also
+     * selected them independently.
+     */
+    implies?: Record<string, string[]>;
+}
+export default function CheckboxGroupField({ field, label, labelPosition, missing, disabled, onChange, tooltipComponent, spaceCompact, setFormDirty, }: FieldComponentProps<ICheckboxGroupField>): import("react").JSX.Element;

package/dist/form/Fields/ColorField.d.ts

@@ -0,0 +1,8 @@
+import type React from 'react';
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+export interface IColorField extends BaseField {
+    type: 'color';
+    default?: string;
+}
+export default function ColorField(props: FieldComponentProps<IColorField>): React.JSX.Element;

package/dist/form/Fields/DropdownField.d.ts

@@ -0,0 +1,24 @@
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+export interface IDropdownField extends BaseField {
+    type: 'dropdown';
+    dropdownType?: string;
+    options: Array<{
+        label: string;
+        value: string;
+        secondaryLabel?: string;
+        description?: string;
+    }> | Record<string, Array<{
+        label: string;
+        value: string;
+        secondaryLabel?: string;
+        description?: string;
+    }>>;
+    parentValue?: string;
+    resetOnChange?: boolean;
+    autoselect?: boolean;
+    allowCustomValue?: boolean;
+    customValueLabel?: string;
+    placeholder?: string;
+}
+export default function DropdownField(props: FieldComponentProps<IDropdownField, string>): import("react").JSX.Element;

package/dist/form/Fields/DurationField.d.ts

@@ -0,0 +1,13 @@
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+export interface IDurationField extends BaseField {
+    type: 'duration';
+    default?: number;
+    min?: number | string;
+    max?: number | string;
+    placeholder?: string;
+    disableValue?: number;
+    disableLabel?: string;
+}
+declare const _default: import("react").MemoExoticComponent<({ field, label, labelPosition, missing, disabled, onChange, tooltipComponent, spaceCompact, setFormDirty, currentValue, setFieldValue, setFieldTouched, }: FieldComponentProps<IDurationField, number | string | undefined>) => import("react").JSX.Element>;
+export default _default;

package/dist/form/Fields/LabelField.d.ts

@@ -0,0 +1,9 @@
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+export interface ILabelField extends BaseField {
+    type: 'label';
+    text?: string;
+    size?: number;
+    bold?: boolean;
+}
+export default function LabelField(props: FieldComponentProps<ILabelField>): import("react").JSX.Element;

package/dist/form/Fields/MultiDropdownField.d.ts

@@ -0,0 +1,18 @@
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+export interface IMultiDropdownField extends BaseField {
+    type: 'multi-dropdown';
+    options: Array<string | {
+        label: string;
+        value: string | boolean | number;
+        secondaryLabel?: string;
+        selected?: boolean;
+    }> | Record<string, Array<string | {
+        label: string;
+        value: string | boolean | number;
+        secondaryLabel?: string;
+        selected?: boolean;
+    }>>;
+    parentValue?: string | boolean | number;
+}
+export default function MultiDropdownField({ field, label, tooltipComponent, labelPosition, spaceCompact, disabled, missing, setFormDirty, onChange, }: FieldComponentProps<IMultiDropdownField>): import("react").JSX.Element;

package/dist/form/Fields/NumberField.d.ts

@@ -0,0 +1,13 @@
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+export interface INumberField extends BaseField {
+    type: 'number';
+    default?: number;
+    prefillDefault?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    placeholder?: string;
+    thousandsSeparator?: boolean;
+}
+export default function NumberField(props: FieldComponentProps<INumberField>): import("react").JSX.Element;

package/dist/form/Fields/ObjectField.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField, DynamicFormSchema } from '../types/fieldTypes.js';
+export interface IObjectField extends BaseField {
+    type: 'object';
+    options: DynamicFormSchema;
+}
+export default function ObjectField({ field, label, tooltipComponent, missingFields, setFormDirty, workflowForm, labelPosition, spaceCompact, }: FieldComponentProps<IObjectField>): React.JSX.Element;

package/dist/form/Fields/RadioField.d.ts

@@ -0,0 +1,9 @@
+import type React from 'react';
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+export interface IRadioField extends BaseField {
+    type: 'radio';
+    options?: string[];
+    optionLabelPosition?: 'left' | 'top';
+}
+export default function RadioField(props: FieldComponentProps<IRadioField>): React.JSX.Element;

package/dist/form/Fields/RangeField.d.ts

@@ -0,0 +1,11 @@
+import type React from 'react';
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+export interface IRangeField extends BaseField {
+    type: 'range';
+    default?: number;
+    min: number;
+    max: number;
+    step?: number;
+}
+export default function RangeField(props: FieldComponentProps<IRangeField>): React.JSX.Element;

package/dist/form/Fields/ResourceOptionIcon.d.ts

@@ -0,0 +1,11 @@
+import { StatusDot } from '../../components/StatusBadge.js';
+import type { ComponentProps } from 'react';
+interface ResourceOptionIconProps {
+    imageUrl?: string;
+    fallbackIcon: string;
+    alt: string;
+    variant?: ComponentProps<typeof StatusDot>['variant'];
+    dotSize?: number;
+}
+export declare function ResourceOptionIcon({ imageUrl, fallbackIcon, alt, variant, dotSize, }: ResourceOptionIconProps): import("react").JSX.Element;
+export {};

package/dist/form/Fields/StepField.d.ts

@@ -0,0 +1,3 @@
+/** Not directly rendered — wizard container handles step fields; this stub satisfies the registry. */
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+export default function StepField(_props: FieldComponentProps<any>): null;

package/dist/form/Fields/StringField.d.ts

@@ -0,0 +1,17 @@
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+export interface IStringField extends BaseField {
+    type: 'string' | 'password';
+    default?: string;
+    placeholder?: string;
+    lowercase?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    sanitize?: string;
+    prefillDefault?: boolean;
+}
+declare const _default: import("react").MemoExoticComponent<(props: FieldComponentProps<IStringField, string>) => import("react").JSX.Element>;
+export default _default;

package/dist/form/Fields/TextAreaField.d.ts

@@ -0,0 +1,8 @@
+import type { FieldComponentProps } from '../types/fieldComponentTypes.js';
+import type { BaseField } from '../types/fieldTypes.js';
+export interface ITextAreaField extends BaseField {
+    type: 'textarea';
+    default?: string;
+    placeholder?: string;
+}
+export default function TextAreaField(props: FieldComponentProps<ITextAreaField>): import("react").JSX.Element;

package/dist/form/Fields/durationValidity.d.ts

@@ -0,0 +1,2 @@
+export declare function setDurationValidity(path: string, valid: boolean): void;
+export declare function getInvalidDurationPaths(): string[];