react-input-material 0.0.762 → 0.0.764

package/dist/components/TextInput/helper.d.ts

@@ -1,38 +0,0 @@
-import type { EditorOptions } from '@tiptap/core';
-import { KeyboardEvent } from 'react';
-import Dummy from 'react-generic-dummy';
-import UseAnimationsType from 'react-useanimations';
-import LockAnimation from 'react-useanimations/lib/lock';
-import PlusToXAnimation from 'react-useanimations/lib/plusToX';
-import { DefaultProperties as DefaultProperties, ModelState as ModelState } from './type';
-export declare const IS_BROWSER: boolean;
-export declare const UseAnimations: (null | typeof Dummy | typeof UseAnimationsType | undefined);
-export declare const lockAnimation: null | typeof LockAnimation | undefined;
-export declare const plusToXAnimation: null | typeof PlusToXAnimation | undefined;
-export declare const CSS_CLASS_NAMES: Record<string, string>;
-export declare const CODE_EDITOR_OPTIONS: {};
-export declare const CURRENT_UTC_BUILD_TIMESTAMP: number;
-export declare const TIPTAP_DEFAULT_OPTIONS: Partial<EditorOptions>;
-/**
- * Derives validation state from provided properties and state.
- * @param properties - Current component properties.
- * @param currentState - Current component state.
- * @returns Boolean indicating whether component is in an aggregated valid or
- * invalid state.
- */
-export declare const determineValidationState: <T>(properties: DefaultProperties<T>, currentState: Partial<ModelState>) => boolean;
-/**
- * Avoid propagating the enter key event since this usually sends a form which
- * is not intended when working in a text field.
- * @param event - Keyboard event.
- */
-export declare function preventEnterKeyPropagation(event: KeyboardEvent): void;
-/**
- * Indicates whether a provided query is matching currently provided
- * suggestion.
- * @param suggestion - Candidate to match again.
- * @param query - Search query to check for matching.
- * @returns Boolean result whether provided suggestion matches given query or
- * not.
- */
-export declare function suggestionMatches(suggestion: string, query?: null | string): boolean;

package/dist/components/TextInput/index.d.ts

@@ -1,44 +0,0 @@
-import { ForwardedRef, ReactElement } from 'react';
-import { AdapterWithReferences, Component, DataTransformation, Props } from './type';
-export { CODE_EDITOR_OPTIONS, CSS_CLASS_NAMES, determineValidationState, preventEnterKeyPropagation, suggestionMatches, TIPTAP_DEFAULT_OPTIONS } from './helper';
-export declare const INPUT_TRANSFORMER: DataTransformation;
-/**
- * Generic text input wrapper component which automatically determines a useful
- * input field depending on given model specification.
- * Dataflow:
- * 1. On-Render all states are merged with given properties into a normalized
- *    property object.
- * 2. Properties, corresponding state values and sub node instances are saved
- *    into a "ref" object (to make them accessible from the outside for example
- *    for wrapper like web-components).
- * 3. Event handler saves corresponding data modifications into state and
- *    normalized properties object.
- * 4. All state changes except selection changes trigger an "onChange" event
- *    which delivers the consolidated properties object (with latest
- *    modifications included).
- * @property displayName - Descriptive name for component to show in web
- * developer tools.
- * @param props - Given components properties.
- * @param reference - Reference object to forward internal state.
- * @returns React elements.
- */
-export declare const TextInputInner: {
-    <Type = unknown>(props: Props<Type>, reference?: ForwardedRef<AdapterWithReferences<Type>>): ReactElement;
-    displayName: string;
-};
-/**
- * Wrapping web component compatible react component.
- * @property defaultModelState - Initial model state.
- * @property defaultProperties - Initial property configuration.
- * @property locales - Defines input formatting locales.
- * @property propTypes - Triggers reacts runtime property value checks.
- * @property strict - Indicates whether we should wrap render output in reacts
- * strict component.
- * @property transformer - Text input data transformation specifications.
- * @property wrapped - Wrapped component.
- * @param props - Given components properties.
- * @param reference - Reference object to forward internal state.
- * @returns React elements.
- */
-export declare const TextInput: Component<typeof TextInputInner>;
-export default TextInput;

package/dist/components/TextInput/type.d.ts

@@ -1,201 +0,0 @@
-import { LanguageSupport } from '@codemirror/language';
-import { JSONContent } from '@tiptap/core';
-import { Mapping, PlainObject, RecursivePartial, ValueOf } from 'clientnode';
-import BasePropertyTypes, { Requireable } from 'clientnode/property-types';
-import { FocusEvent as ReactFocusEvent, ForwardRefExoticComponent, KeyboardEvent, MouseEvent, ReactElement, ReactNode, RefAttributes, MutableRefObject as RefObject } from 'react';
-import { GenericEvent } from 'react-generic-tools/type';
-import { ComponentAdapter, ValidationMapping } from 'web-component-wrapper/type';
-import { ChainedCommands, type EditorOptions, Extensions } from '@tiptap/core';
-import { EditorEvents } from '@tiptap/react';
-import { StarterKitOptions } from '@tiptap/starter-kit';
-import { IconProperties, InputReference, SelectProperties, TextAreaProperties, TextFieldProperties } from '../../implementations/type';
-import { BaseModel, CursorState, NormalizedSelection, ModelState as BaseModelState, Properties as BaseProperties, Selection, State as BaseState, StaticWebComponent, ValueState as BaseValueState } from '../../type';
-import { Reference as InputEventMapperReference } from './InputEventMapperWrapper';
-export type Transformer<T = unknown> = (value: T, transformer: DataTransformation, configuration: DefaultProperties<T>) => string;
-export interface FormatSpecification<T = unknown> {
-    options?: PlainObject;
-    transform?: Transformer<T>;
-}
-export interface FormatSpecifications<T = unknown> {
-    final: FormatSpecification<T>;
-    intermediate?: FormatSpecification<T>;
-}
-export interface DataTransformSpecification<T = unknown, InputType = number | string> {
-    format?: FormatSpecifications<T>;
-    parse?: (value: InputType, transformer: DataTransformation, configuration: DefaultProperties<T>) => T;
-    type?: NativeType;
-}
-export interface DateTransformSpecification extends DataTransformSpecification<number | string, Date | number | string> {
-    useISOString: boolean;
-}
-export type DataTransformation = {
-    boolean: DataTransformSpecification<boolean>;
-    currency: DataTransformSpecification<number, string>;
-    date: DateTransformSpecification;
-    'date-local': DataTransformSpecification<number | string, Date | number | string>;
-    datetime: DataTransformSpecification<number | string, Date | number | string>;
-    'datetime-local': DataTransformSpecification<number | string, Date | number | string>;
-    time: DataTransformSpecification<number | string, Date | number | string>;
-    'time-local': DataTransformSpecification<number | string, Date | number | string>;
-    float: DataTransformSpecification<number, string>;
-    integer: DataTransformSpecification<number, string>;
-    number: DataTransformSpecification<number, number>;
-    string?: DataTransformSpecification;
-} & {
-    [key in Exclude<NativeType, ('date' | 'date-local' | 'datetime' | 'datetime-local' | 'time' | 'time-local' | 'number')>]?: DataTransformSpecification;
-};
-export interface EditorReference {
-    input: RefObject<InputEventMapperReference | null>;
-}
-export interface EditorProperties extends Omit<NonNullable<TextAreaProperties>, 'onChange' | 'textarea' | 'value'> {
-    id: string;
-    value: number | string;
-    minimumLength: number;
-    maximumLength: number;
-    rows: number;
-    onChange: (value: string, contentTree?: JSONContent) => void;
-}
-export interface RichTextEditorButtonProps {
-    action: (command: ChainedCommands) => ChainedCommands;
-    activeIndicator?: string;
-    enabledIndicator?: null | ((command: ChainedCommands) => ChainedCommands);
-    checkedIconName?: string;
-    iconName: string;
-    label?: string;
-}
-export interface TiptapProperties extends Omit<EditorProperties, 'onBlur' | 'onFocus'> {
-    onBlur: (event: EditorEvents['focus']) => void;
-    onFocus: (event: EditorEvents['focus']) => void;
-    editor: {
-        options?: Partial<EditorOptions>;
-        extensions?: Extensions;
-        starterKitOptions?: Partial<StarterKitOptions>;
-    };
-}
-export type TiptapProps = Partial<TiptapProperties>;
-export interface CodeMirrorProperties extends Omit<EditorProperties, 'onBlur' | 'onFocus'> {
-    onBlur: (event: ReactFocusEvent<HTMLDivElement>) => void;
-    onFocus: (event: ReactFocusEvent<HTMLDivElement>) => void;
-    editor: {
-        mode?: LanguageSupport;
-    };
-}
-export type CodeMirrorProps = Partial<CodeMirrorProperties>;
-export interface ModelState extends BaseModelState {
-    invalidMaximum: boolean;
-    invalidMinimum: boolean;
-    invalidMaximumLength: boolean;
-    invalidMinimumLength: boolean;
-    invalidInvertedPattern: boolean;
-    invalidPattern: boolean;
-}
-export interface Model<T = unknown> extends BaseModel<T> {
-    default?: T;
-    state?: ModelState;
-}
-export type PartialModel<T = unknown> = Partial<Omit<Model<T>, 'state'>> & {
-    state?: Partial<ModelState>;
-};
-export interface ValueState<T = unknown, MS = BaseModelState> extends BaseValueState<T, MS> {
-    representation?: ReactNode;
-}
-export type NativeType = ('date' | 'datetime-local' | 'time' | 'week' | 'month' | 'number' | 'range' | 'text');
-export type Type = ('date-local' | 'datetime' | 'time-local' | 'boolean' | 'currency' | 'float' | 'integer' | 'string' | NativeType);
-export interface ChildrenOptions<P, T> {
-    index: number;
-    normalizedSelection?: NormalizedSelection | null;
-    properties: P;
-    query: string;
-    suggestion: ReactNode | string;
-    value: T;
-}
-export interface SuggestionCreatorOptions<P> {
-    abortController: AbortController;
-    properties: P;
-    query: string;
-}
-export type EditorType = ('code' | 'code(css)' | 'code(cascadingstylesheet)' | 'code(cascadingstylesheets)' | 'code(style)' | 'code(styles)' | 'code(script)' | 'code(js)' | 'code(jsx)' | 'code(javascript)' | 'code(ts)' | 'code(tsx)' | 'code(typescript)' | 'plain' | 'text' | 'richtext');
-export interface Properties<Type = unknown> extends ModelState, BaseProperties<Type> {
-    default?: Type;
-    align: 'end' | 'start';
-    children: (options: ChildrenOptions<this, Type>) => null | ReactElement;
-    cursor: Partial<CursorState> | null;
-    editor: EditorType;
-    editorIsActive: boolean;
-    editorIsInitiallyActive: boolean;
-    hidden?: boolean;
-    leadingIcon: string | (IconProperties & {
-        tooltip?: string;
-    });
-    trailingIcon: string | (IconProperties & {
-        tooltip?: string;
-    });
-    domNodeProperties: Partial<CodeMirrorProps | SelectProperties<Type> | TiptapProps | TextAreaProperties | TextFieldProperties | Mapping<unknown>>;
-    attributes?: Mapping<boolean | number | string>;
-    invertedPattern: Array<RegExp | string> | null | RegExp | string;
-    invertedPatternText: string;
-    labels: Selection;
-    maximumLengthText: string;
-    minimumLengthText: string;
-    maximumText: string;
-    minimumText: string;
-    model: Model<Type>;
-    onChangeEditorIsActive: (isActive: boolean, event: MouseEvent | undefined, properties: this) => void;
-    onKeyDown: (event: KeyboardEvent, properties: this) => void;
-    onKeyUp: (event: KeyboardEvent, properties: this) => void;
-    onSelect: (event: GenericEvent, properties: this) => void;
-    onSelectionChange: (event: GenericEvent, properties: this) => void;
-    pattern: Array<RegExp | string> | null | RegExp | string;
-    patternText: string;
-    placeholder: string;
-    representation: ReactNode | string;
-    rows: number;
-    searchSelection: boolean;
-    selectableEditor: boolean;
-    step: number;
-    suggestionCreator?: (options: SuggestionCreatorOptions<this>) => Properties['selection'] | Promise<Properties['selection']>;
-    suggestSelection: boolean;
-    transformer: RecursivePartial<DataTransformSpecification<Type, Date | number | string>>;
-}
-export type Props<T = unknown> = Partial<Omit<Properties<T>, 'model'>> & {
-    model?: PartialModel<T>;
-};
-export type DefaultProperties<T = string> = Omit<Props<T>, 'model'> & {
-    model: Model<T>;
-};
-export type PropertyTypes<T = unknown> = {
-    [key in keyof Properties<T>]: ValueOf<typeof BasePropertyTypes>;
-};
-export interface State<T = unknown> extends BaseState<T> {
-    cursor: CursorState;
-    editorIsActive: boolean;
-    hidden?: boolean;
-    modelState: ModelState;
-    representation?: ReactNode | string;
-    selectionIsUnstable: boolean;
-    showDeclaration: boolean;
-}
-export type Adapter<T = unknown> = ComponentAdapter<Properties<T>, Omit<State<T>, 'representation' | 'selectionIsUnstable' | 'value'> & {
-    representation?: ReactNode | string;
-    value?: null | T;
-}>;
-export interface AdapterWithReferences<T = unknown> extends Adapter<T> {
-    references: {
-        input: RefObject<InputReference | InputEventMapperReference | null>;
-        menu: RefObject<unknown>;
-        wrapper: RefObject<HTMLDivElement | null>;
-    };
-}
-export interface Component<Type> extends Omit<ForwardRefExoticComponent<Props>, 'propTypes'>, StaticWebComponent<Type, ModelState, DefaultProperties> {
-    <T = unknown>(props: Props<T> & RefAttributes<Adapter<T>>): ReactElement;
-    locales: Array<string>;
-    transformer: DataTransformation;
-}
-export declare const modelStatePropertyTypes: {
-    [key in keyof ModelState]: Requireable<boolean | symbol>;
-};
-export declare const propertyTypes: ValidationMapping;
-export declare const renderProperties: Array<string>;
-export declare const defaultModelState: ModelState;
-export declare const defaultInputModel: Model<string>;
-export declare const defaultProperties: DefaultProperties;

package/dist/components/Wrapper/WrapConfigurations.d.ts

@@ -1,37 +0,0 @@
-import { ThemePropT } from '@rmwc/types';
-import { AnyFunction, FirstParameter } from 'clientnode';
-import { FunctionComponent, ReactElement } from 'react';
-import { ConfigurationProperties } from '../../type';
-/**
- * Wraps a theme provider, strict wrapper and tooltip to given element if
- * corresponding configurations are provided.
- * @param properties - Component provided properties.
- * @param properties.children - Component or string to wrap.
- * @param properties.strict - Indicates whether to render in strict mode.
- * @param properties.themeConfiguration - Optional theme configurations.
- * @param properties.tooltip - Optional tooltip to show on hover.
- * @param properties.wrap - Instead of injecting a div tag, wrap a child
- * component by merging the theme styles directly onto it. Useful when you
- * don't want to mess with layout.
- * @returns Wrapped content.
- */
-export declare const WrapConfigurations: FunctionComponent<ConfigurationProperties & {
-    children: ReactElement;
-}>;
-/**
- * Component factory to dynamically create a wrapped component.
- * @param WrappedComponent - Component to wrap.
- * @param options - Options configure wrapping.
- * @param options.withReference - Indicates whether to add a mutable reference
- * to wrapping component.
- * @param options.withThemeWrapper - Indicates whether all theme configurations
- * should be provided.
- * @returns Created wrapped component.
- */
-export declare function createWrapConfigurationsComponent<Type extends AnyFunction = AnyFunction, Reference = unknown>(WrappedComponent: Type, options?: {
-    withReference?: boolean | null;
-    withThemeWrapper?: boolean;
-}): FunctionComponent<FirstParameter<Type> & ConfigurationProperties & {
-    theme?: ThemePropT;
-}>;
-export default WrapConfigurations;

package/dist/components/Wrapper/WrapStrict.d.ts

@@ -1,14 +0,0 @@
-import { FunctionComponent, ReactNode } from 'react';
-/**
- * Generic strict wrapper component.
- * @param properties - Provided component properties.
- * @param properties.children - Components to wrap.
- * @param properties.strict - Indicates whether to wrap with strict indicating
- * component.
- * @returns React component.
- */
-export declare const WrapStrict: FunctionComponent<{
-    children: ReactNode;
-    strict: boolean;
-}>;
-export default WrapStrict;

package/dist/components/Wrapper/WrapThemeProvider.d.ts

@@ -1,18 +0,0 @@
-import { FunctionComponent, ReactElement } from 'react';
-import { ThemeProviderProps } from '@rmwc/theme';
-/**
- * Wraps a theme provider to given element if a configuration is provided.
- * @param properties - Component provided properties.
- * @param properties.children - Component or string to wrap.
- * @param properties.configuration - Potential theme provider configuration.
- * @param properties.wrap - Instead of injecting a div tag, wrap a child
- * component by merging the theme styles directly onto it. Useful when you
- * don't want to mess with layout.
- * @returns Wrapped content.
- */
-export declare const WrapThemeProvider: FunctionComponent<{
-    children: ReactElement;
-    configuration?: ThemeProviderProps['options'];
-    wrap?: boolean;
-}>;
-export default WrapThemeProvider;

package/dist/components/Wrapper/WrapTooltip.d.ts

@@ -1,16 +0,0 @@
-import { FunctionComponent, ReactElement } from 'react';
-import { Properties } from '../../type';
-export declare const isDummy: boolean;
-/**
- * Wraps given component with a tooltip component with given tooltip
- * configuration.
- * @param properties - Component provided properties.
- * @param properties.children - Component or string to wrap.
- * @param properties.value - Tooltip value.
- * @returns Wrapped given content.
- */
-export declare const WrapTooltip: FunctionComponent<{
-    children: ReactElement;
-    value?: Properties['tooltip'] | null;
-}>;
-export default WrapTooltip;

package/dist/helper.d.ts

@@ -1,164 +0,0 @@
-import { Mapping } from 'clientnode';
-import { NullSymbol, UndefinedSymbol } from 'clientnode/property-types';
-import { ReactNode, useState } from 'react';
-import { BaseProperties, BaseProps, DefaultBaseProperties, DefaultProperties, ModelState, NormalizedSelection, Selection, ValueState } from './type';
-import { DateTimeRepresentation } from './components/Interval/type';
-import { DefaultProperties as TextInputDefaultProperties, DataTransformation as TextInputDataTransformation, Props as TextInputProps } from './components/TextInput/type';
-/**
- * Removes all none serializable values from given data structure.
- * @param object - Mapping of values to slice.
- */
-export declare const slicePropertiesForState: (object: Mapping) => void;
-/**
- * Removes all none serializable values from given data structure recursively.
- * @param properties - Mapping of values to slice.
- * @returns Nothing.
- */
-export declare const slicePropertiesForStateRecursively: (properties: unknown) => object | undefined;
-/**
- * Creates a mocked a state setter. Useful to dynamically convert a component
- * from uncontrolled to controlled one.
- * @param value - Parameter for state setter.
- * @returns Resulting value of the "useState" hook.
- */
-export declare const createDummyStateSetter: <Type = unknown>(value: Type) => ReturnType<typeof useState>[1];
-/**
- * Consolidates properties not found in properties but in state into
- * properties.
- * @param properties - To consolidate.
- * @param state - To search values in.
- * @returns Consolidated properties.
- */
-export declare const deriveMissingPropertiesFromState: <Properties extends BaseProps = BaseProps, State extends ValueState = ValueState>(properties: Properties, state: State) => Properties;
-/**
- * Creates a hybrid a state setter which only triggers when model state changes
- * occur. Useful to dynamically convert a component from uncontrolled to
- * controlled while model state should be uncontrolled either.
- * @param setValueState - Value setter to wrap.
- * @param currentValueState - Last known value state to provide to setter when
- * called.
- * @returns Wrapped given method.
- */
-export declare const wrapStateSetter: <Type = unknown>(setValueState: (value: Type | ((value: Type) => Type)) => void, currentValueState: Type) => ReturnType<typeof useState>[1];
-/**
- * Renders given template string against all properties in current
- * instance.
- * @param template - Template to render.
- * @param scope - Scope to render given template again.
- * @returns Evaluated template or an empty string if something goes wrong.
- */
-export declare const renderMessage: <Scope extends object = object>(template: unknown, scope: Scope) => string;
-/**
- * Triggered when a value state changes like validation or focusing.
- * @param properties - Properties to search in.
- * @param name - Event callback name to search for in given properties.
- * @param synchronous - Indicates whether to trigger callback immediately or
- * later. Controlled components should call synchronously and uncontrolled
- * otherwise as long as callbacks are called in a state setter context.
- * @param parameters - Additional arguments to forward to callback.
- */
-export declare const triggerCallbackIfExists: <P extends Omit<BaseProperties, "model"> & {
-    model: unknown;
-}>(properties: P, name: string, synchronous?: boolean, ...parameters: Array<unknown>) => void;
-/**
- * Translate known symbols in a copied and return properties object.
- * @param properties - Object to translate.
- * @returns Transformed properties.
- */
-export declare const translateKnownSymbols: <Type = unknown>(properties: Mapping<typeof NullSymbol | Type | typeof UndefinedSymbol>) => Mapping<Type>;
-/**
- * Determines initial value representation as string.
- * @param properties - Components properties.
- * @param defaultProperties - Components default properties.
- * @param value - Current value to represent.
- * @param transformer - To apply to given value.
- * @param selection - Data mapping of allowed values.
- * @returns Determined initial representation.
- */
-export declare function determineInitialRepresentation<T = unknown, P extends TextInputProps<T> = TextInputProps<T>, DP extends TextInputDefaultProperties<T> = TextInputDefaultProperties<T>>(properties: P, defaultProperties: DP, value: null | T, transformer: TextInputDataTransformation, selection?: NormalizedSelection | null): string;
-/**
- * Determines initial value depending on given properties.
- * @param properties - Components properties.
- * @param defaultValue - Internal fallback value.
- * @param alternateValue - Alternate value to respect.
- * @returns Determined value.
- */
-export declare const determineInitialValue: <Type = unknown, DefaultType = unknown>(properties: BaseProps & {
-    default?: DefaultType;
-    model?: {
-        default?: DefaultType;
-    };
-}, defaultValue?: Type, alternateValue?: Type) => null | Type;
-/**
- * Derives current validation state from given value.
- * @param properties - Input configuration.
- * @param currentState - Current validation state.
- * @param validators - Mapping from validation state key to corresponding
- * validator function.
- * @returns A boolean indicating if validation state has changed.
- */
-export declare const determineValidationState: <Type = unknown, P extends DefaultProperties<Type> = DefaultProperties<Type>, MS extends Partial<ModelState> = Partial<ModelState>>(properties: P, currentState: MS, validators?: Mapping<() => boolean>) => boolean;
-/**
- * Synchronizes property, state and model configuration:
- * Properties overwrites default properties which overwrites default model
- * properties.
- * @param properties - Properties to merge.
- * @param defaultModel - Default model to merge.
- * @returns Merged properties.
- */
-export declare const mapPropertiesIntoModel: <P extends BaseProps = BaseProps, DP extends DefaultBaseProperties = DefaultBaseProperties>(properties: P, defaultModel: DP["model"]) => DP;
-/**
- * Calculate external properties (a set of all configurable properties).
- * @param properties - Properties to merge.
- * @returns External properties object.
- */
-export declare const getConsolidatedProperties: <P extends BaseProps, R extends BaseProperties>(properties: P) => R;
-/**
- * Determine normalized labels and values for selection and auto-complete
- * components.
- * @param selection - Selection component property configuration.
- * @returns Normalized sorted listed of labels and values.
- */
-export declare function getLabelAndValues(selection?: NormalizedSelection | null): [Array<ReactNode | string>, Array<unknown>];
-/**
- * Determine representation for given value while respecting existing labels.
- * @param value - To represent.
- * @param selection - Selection component property configuration.
- * @returns Determined representation.
- */
-export declare function getRepresentationFromValueSelection(value: unknown, selection?: NormalizedSelection | null): null | string;
-/**
- * Determine value from provided representation (for example user inputs).
- * @param label - To search a value for.
- * @param selection - Selection component property configuration.
- * @returns Determined value.
- */
-export declare function getValueFromSelection<T>(label: ReactNode | string, selection: NormalizedSelection | null | undefined): T;
-/**
- * Normalize given selection. NOTE: It is important to have an ordered list
- * to map values to labels and the other way around in a deterministic way.
- * @param selection - Selection component property configuration.
- * @param labels - Additional labels to take into account (for example provided
- * via a content management system).
- * @returns Determined normalized sorted selection configuration.
- */
-export declare function normalizeSelection(selection?: Selection | null, labels?: Selection | null): NormalizedSelection | null | undefined;
-/**
- * Applies configured value transformations.
- * @param configuration - Input configuration.
- * @param value - Value to transform.
- * @param transformer - To apply to given value.
- * @param trim - Indicates whether to trim strings or not.
- * @returns Transformed value.
- */
-export declare const parseValue: <T = unknown, P extends TextInputDefaultProperties<T> = TextInputDefaultProperties<T>, InputType = T>(configuration: P, value: InputType | undefined, transformer: TextInputDataTransformation, trim?: boolean) => T;
-/**
- * Represents configured value as string.
- * @param configuration - Input configuration.
- * @param value - To represent.
- * @param transformerMapping - To apply to given value.
- * @param final - Specifies whether it is a final representation.
- * @returns Transformed value.
- */
-export declare function formatValue<T = unknown, P extends TextInputDefaultProperties<T> = TextInputDefaultProperties<T>>(configuration: P, value: null | T, transformerMapping: TextInputDataTransformation, final?: boolean): string;
-export declare const formatDateTimeAsConfigured: (value?: DateTimeRepresentation | Date | null) => DateTimeRepresentation | null | undefined;

package/dist/index.d.ts

@@ -1,16 +0,0 @@
-export { Checkbox } from './components/Checkbox';
-export { FileInput } from './components/FileInput';
-export { Interval } from './components/Interval';
-export { Inputs } from './components/Inputs';
-export { TextInput } from './components/TextInput';
-export { WrapConfigurations } from './components/Wrapper/WrapConfigurations';
-export { WrapStrict } from './components/Wrapper/WrapStrict';
-export { WrapThemeProvider } from './components/Wrapper/WrapThemeProvider';
-export { WrapTooltip } from './components/Wrapper/WrapTooltip';
-export * from './helper';
-export * from './type';
-export * as CheckboxTypes from './components/Checkbox/type';
-export * as FileInputTypes from './components/FileInput/type';
-export * as IntervalTypes from './components/Interval/type';
-export * as InputsTypes from './components/Inputs/type';
-export * as TextInputTypes from './components/TextInput/type';