@parallelworks/ui 0.1.0 → 0.3.0

package/dist/file-explorer/lib/batch.d.ts

@@ -0,0 +1,3 @@
+export declare function paginate<TPage>(fetchPage: (cursor?: string) => Promise<TPage>, nextCursor: (page: TPage) => string | undefined): AsyncGenerator<TPage>;
+export declare function chunk<T>(items: readonly T[], size: number): T[][];
+export declare function mapWithConcurrency<T, R>(items: readonly T[], limit: number, worker: (item: T) => Promise<R>): Promise<PromiseSettledResult<R>[]>;

package/dist/file-explorer/lib/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class CorsError extends Error {
+    constructor(message?: string);
+}

package/dist/file-explorer/lib/fileExplorer.d.ts

@@ -0,0 +1,32 @@
+import type { TListPageRequest } from './paging.js';
+import type { TreeNode, TStorage, TStorageObject } from './types.js';
+/** Every provider resolves get-file as a [url, error] tuple. */
+export type FileExplorerGetFileResult = [string | null, Error | null];
+/** The UI only checks Errors?.length; each provider's richer error entries
+ *  satisfy this structurally. */
+export interface FileExplorerDeleteFilesResult {
+    Errors?: unknown[];
+}
+export interface IFileExplorerClient {
+    getStorageName(): string;
+    getExpiresAt(): Date;
+    getFile(input: unknown): Promise<FileExplorerGetFileResult>;
+    listDirectory(input: unknown): Promise<unknown>;
+    deleteFiles(input: unknown): Promise<FileExplorerDeleteFilesResult>;
+    uploadFile(input: unknown, onProgress?: (progress: {
+        loadedBytes: number;
+        totalBytes: number;
+        percentage: number;
+    }) => void, abortController?: AbortController): Promise<unknown>;
+}
+export interface IFileExplorerProvider {
+    createClient: ((organization: string, username: string, name: string) => Promise<IFileExplorerClient | null>) | null;
+    convertDataToStorageObjects?(data: unknown): TStorageObject[];
+    /** Absent ⇒ the explorer treats one page as the whole directory. Method syntax for
+     *  the same bivariance reason as the two above. */
+    nextPageCursor?(data: unknown): string | undefined;
+    listDirectoryInput?: ((storage: TStorage, dir_path?: string, page?: TListPageRequest) => unknown) | null;
+    getFileInput?: ((storageName: string, node: TreeNode, presignedUrlExpiresIn?: number) => unknown) | null;
+    deleteFilesInput?: ((storageName: string, nodes: TreeNode[]) => unknown) | null;
+    uploadFileInput?: ((storageName: string, objectPath: string, file: File | Blob) => unknown) | null;
+}

package/dist/file-explorer/lib/paging.d.ts

@@ -0,0 +1,93 @@
+import type { TStorageObject } from './types.js';
+/** Both providers already cap an unqualified list at 1,000, so stating it leaves
+ *  single-page directories byte-identical. */
+export declare const LIST_PAGE_SIZE = 1000;
+export type TListPageRequest = {
+    cursor?: string;
+    /** Overridable so a test can page without seeding 2,000 objects. */
+    pageSize?: number;
+};
+/** Keyed by tree path. A storage's flat `objects` bag cannot say whether a directory
+ *  was listed at all, only whether anything landed under it. */
+export type TDirectoryListing = {
+    /** Present ⇒ more entries exist and the provider can resume from here. */
+    cursor?: string;
+    /** 0 ⇒ never listed, which is what tells "empty" apart from "not asked yet". */
+    pagesLoaded: number;
+    /** Not `loadingPaths`, which swaps the whole table for a skeleton and would blank
+     *  the rows being read. */
+    loadingMore: boolean;
+    /** The storage-level error surfaces only on an empty folder, so without this a
+     *  failure mid-folder is invisible. */
+    error?: string;
+};
+/** Uncapped, opening a 200k-object folder and scrolling would walk all of it. */
+export declare const MAX_AUTO_PAGES = 5;
+export type TListings = ReadonlyMap<string, TDirectoryListing>;
+export declare function isListed(listings: TListings, path: string): boolean;
+/** True even while a request is in flight, so the sentinel stays put. */
+export declare function hasMore(listings: TListings, path: string): boolean;
+/** Auto-load stops at the cap; past it the user asks for each page. */
+export declare function canAutoLoadMore(listings: TListings, path: string): boolean;
+export declare function isLoadingMore(listings: TListings, path: string): boolean;
+export declare function loadMoreError(listings: TListings, path: string): string | undefined;
+export declare function beginLoadingMore(listings: TListings, path: string): TListings;
+/** `expectedPagesLoaded` is captured before the request: a mismatch means a refresh
+ *  reset this directory while the page was in flight. */
+export declare function advanceListing(listings: TListings, path: string, page: {
+    cursor?: string;
+}, expectedPagesLoaded: number): TListings;
+/** Always a new map, since the hydration walk only re-runs on a `listings` change.
+ *  `pagesLoaded` stays put, so a failed first page still reads as unlisted. */
+export declare function recordListingError(listings: TListings, path: string, error: string): TListings;
+/** Slash-terminates the prefix: without it, clearing `logs` would also clear
+ *  `logs-archive/`. */
+export declare function clearListingsUnder(listings: TListings, path: string): TListings;
+/** The same prefix rule for the attempt sets that shadow `listings`. They gate
+ *  re-listing, so a path left behind here reads as tried-and-empty forever. */
+export declare function forgetPathsUnder(paths: Set<string>, path: string): void;
+/** Tree paths whose children should keep arrival order, since sorting them would
+ *  reshuffle rows under the user mid-scroll. */
+export declare function incompletePaths(listings: TListings): Set<string>;
+/** Reached only when the target is deep inside a directory of well over 20,000
+ *  entries, where the alternative is draining it all. */
+export declare const MAX_HYDRATION_PAGES = 20;
+type THydrationStep = 
+/** List this directory's first page. */
+{
+    kind: 'fetch';
+    path: string;
+}
+/** Pull another page; the target is not in what we have. */
+ | {
+    kind: 'more';
+    path: string;
+} | {
+    kind: 'stuck';
+}
+/** Either resolved, or a request is already in flight. */
+ | {
+    kind: 'done';
+};
+/** What a deep link needs next. Pure so the walk is table-testable. */
+export declare function nextHydrationStep({ targetResolved, ancestors, isListableDir, listings, inFlight, attempted, pagesPulled, }: {
+    targetResolved: boolean;
+    /** Directory paths from the storage root down to the target.  */
+    ancestors: readonly string[];
+    /** False above the storage root, and false for a directory a page has not
+     *  introduced yet. */
+    isListableDir: (path: string) => boolean;
+    listings: TListings;
+    /** Must not be a state value: `attempted` is a ref, so a state-backed signal would
+     *  lag it by a render and make an in-flight ancestor read as stuck. */
+    inFlight: ReadonlySet<string>;
+    attempted: ReadonlySet<string>;
+    pagesPulled: number;
+}): THydrationStep;
+/** `replace` drops the directory's previous contents first, which is how a refresh
+ *  sheds deleted objects rather than re-adding them. */
+export declare function nextObjects(previous: TStorageObject[], page: TStorageObject[], options: {
+    replace?: boolean;
+    dirPath: string;
+}): TStorageObject[];
+export {};

package/dist/file-explorer/lib/types.d.ts

@@ -0,0 +1,92 @@
+import type { IFileExplorerClient, IFileExplorerProvider } from './fileExplorer.js';
+export type TStorage = {
+    id: string;
+    name: string;
+    bucketName?: string;
+    user: string;
+    displayName?: string;
+    type?: string;
+    created?: string;
+    modified?: string;
+    region?: string;
+    csp?: string;
+    imageUrl?: string;
+    canWrite?: boolean | undefined;
+    canUpload?: boolean | undefined;
+    canShare?: boolean | undefined;
+    canManageAccess?: boolean | undefined;
+    supportsPwUri?: boolean | undefined;
+    objects?: TStorageObject[];
+};
+export type TStorageObject = {
+    path: string;
+    type: 'file' | 'directory';
+    key?: string;
+    size?: number;
+    created?: string;
+    modified?: string;
+    contentType?: string;
+    hash?: string;
+    storageClass?: string;
+};
+export type TreeNode = {
+    name: string;
+    displayName?: string;
+    path: string;
+    relativePath?: string;
+    type: 'file' | 'directory';
+    size?: number;
+    created?: string;
+    modified?: string;
+    contentType?: string;
+    hash?: string;
+    storageClass?: string;
+    storageId?: string;
+    storageName?: string;
+    storageNodeIcon?: string;
+    storageImageUrl?: string;
+    storageType?: string;
+    root?: boolean;
+};
+export type TreeMap = {
+    [path: string]: TreeNode;
+};
+export type UploadNode = {
+    name: string;
+    file: File | Blob;
+    relativePath: string;
+};
+export interface UploadFileProgress {
+    fileKey: string;
+    fileSizeBytes: number;
+    loadedBytes?: number;
+    totalBytes?: number;
+    percentage?: number;
+    abortController?: AbortController;
+    status?: 'pending' | 'uploading' | 'completed' | 'failed' | 'cancelled';
+}
+export interface UploadSession {
+    id: string;
+    storageName: string;
+    targetPath: string;
+    uploadNodes: UploadNode[];
+    status: 'queued' | 'uploading' | 'completed' | 'failed' | 'cancelled';
+    queueIndex: number;
+    client: IFileExplorerClient;
+    provider: IFileExplorerProvider;
+    progress?: {
+        completedFiles: number;
+        totalFiles: number;
+        totalSizeBytes: number;
+        allFiles?: Map<string, UploadFileProgress>;
+        overallProgress?: number;
+        totalLoadedBytes?: number;
+        lastProgressTime?: number;
+        lastProgressBytes?: number;
+        estimatedSecondsLeft?: number;
+    };
+    toastId: string;
+    abortController?: AbortController;
+    targetNode: TreeNode;
+    refreshTargetNode: (targetNode: TreeNode) => Promise<unknown>;
+}

package/dist/file-explorer/lib/utils.d.ts

@@ -0,0 +1,37 @@
+import type { IFileExplorerClient } from './fileExplorer.js';
+import type { TStorage, TreeMap, TreeNode, UploadNode } from './types.js';
+export declare function formatFileSize(bytes: number): string;
+export declare function getFileExtension(filename: string): string | null;
+export declare function buildTreeFromUserStorages(storages: TStorage[], options?: {
+    forceUserHierarchy?: boolean;
+    unsortedParents?: ReadonlySet<string>;
+}): {
+    treeMap: TreeMap;
+    parentToChildrenMap: Record<string, TreeNode[]>;
+};
+export declare function getNodeChildren(parentToChildrenMap: Record<string, TreeNode[]>, parentPath: string): TreeNode[];
+export declare function getParentPath(currentPath: string): string;
+export type DirectoryNameError = 'reserved' | 'separator' | 'exists';
+export declare function getDirectoryNameError(name: string, siblings: TreeNode[]): DirectoryNameError | null;
+export declare function getDirectoryObjectPath(parentNode: TreeNode, directoryName: string): string;
+export declare function getUploadNodesFromDataTransferItems(items: DataTransferItemList): Promise<{
+    uploadNodes: UploadNode[];
+    totalSize: number;
+}>;
+export declare function calculateUploadNodesTotalSize(uploadNodes: UploadNode[]): number;
+export declare function getObjectKeyFromNode(node: TreeNode): string;
+export declare function getDirectoryPrefixFromNode(node: TreeNode): string;
+export declare function pruneNodesInsideSelectedDirectories(nodes: TreeNode[]): TreeNode[];
+export declare function collectObjectKeysToDelete(nodes: TreeNode[], listKeysUnderPrefix: (prefix: string) => Promise<string[]>): Promise<string[]>;
+export declare function getPwUri(username: string, pwName: string, key: string): string;
+export declare function getCspUri(csp: string, cspBucketName: string, key: string): string | null;
+export declare function removeLeadingSlash(path: string): string;
+export declare function removeLeadingAndTrailingSlashes(path: string): string;
+export declare function isClientValid(client: IFileExplorerClient): boolean;
+export declare function getUploadSessionETA(totalLoadedBytes: number, totalSizeBytes: number, lastProgressTime?: number, lastProgressBytes?: number): {
+    estimatedSecondsLeft?: number;
+    lastProgressTime: number;
+    lastProgressBytes: number;
+    shouldUpdateETA: boolean;
+};
+export declare function formatETA(seconds: number): string;

package/dist/file-explorer/toasts.d.ts

@@ -0,0 +1,9 @@
+import type { UploadSession } from './lib/types.js';
+interface UploadSessionToastProps {
+    session: UploadSession;
+    queueLength: number;
+    onCancel?: () => void;
+    onCancelFile?: (relativePath: string) => void;
+}
+export declare function UploadSessionToast({ session, queueLength, onCancel, onCancelFile, }: UploadSessionToastProps): import("react").JSX.Element;
+export {};

package/dist/file-explorer/treeRows.d.ts

@@ -0,0 +1,35 @@
+import type { TreeNode } from './lib/types.js';
+/** 10,000 file rows render cheaply but stand 300,000px tall, burying the folder's
+ *  next sibling. Directories are never held back. */
+export declare const TREE_FILE_CAP = 50;
+/** One visible line in the sidebar tree. */
+export interface TreeRow {
+    kind: 'node' | 'skeleton' | 'more';
+    /** Non-node rows suffix the parent path after a NUL, which object keys effectively
+     *  never contain; nothing is derived from the key, so a collision only warns. */
+    key: string;
+    node: TreeNode;
+    /** Roots are 0. Drives indent and aria-level (which is 1-based). */
+    depth: number;
+    posInSet: number;
+    /** The true sibling count, which aria-setsize wants even when the cap shows fewer. */
+    setSize: number;
+    isExpanded: boolean;
+    /** `more` rows only: files held back by the cap, 0 when only pages remain. */
+    hiddenFiles?: number;
+}
+interface FlattenTreeOptions {
+    loadingPaths?: ReadonlySet<string>;
+    incompletePaths?: ReadonlySet<string>;
+    /** Absent means `TREE_FILE_CAP`. */
+    fileLimits?: ReadonlyMap<string, number>;
+}
+/** Flattens the tree to exactly the rows that should be on screen, so the sidebar
+ *  can be windowed and keyboard navigation can move by index instead of by DOM. */
+export declare function flattenTreeRows(roots: TreeNode[], parentToChildrenMap: Record<string, TreeNode[]>, expandedPaths: ReadonlySet<string>, options?: FlattenTreeOptions): TreeRow[];
+export declare function nextFileLimit(current: number | undefined): number;
+/** Index of `path` among the visible rows, or -1. */
+export declare function findRowIndex(rows: readonly TreeRow[], path: string): number;
+/** The next selectable row in `direction`, skipping skeleton and more rows. */
+export declare function stepRow(rows: readonly TreeRow[], from: number, direction: 1 | -1): TreeRow | undefined;
+export {};

package/dist/file-explorer/useNearEnd.d.ts

@@ -0,0 +1,7 @@
+import { type RefObject } from 'react';
+/** Fires once the element comes within 100px of the bottom of `root`. */
+export declare function useNearEnd(ref: RefObject<Element | null>, { active, root, onNear, }: {
+    active: boolean;
+    root: HTMLElement | null;
+    onNear: () => void;
+}): 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[];