react-input-material 0.0.352 → 0.0.356

package/components/RequireableCheckbox.tsx

@@ -18,7 +18,6 @@
 */
 // region imports
 import Tools from 'clientnode'
-import {FirstParameter} from 'clientnode/type'
 import {
     FocusEvent as ReactFocusEvent,
     forwardRef,
@@ -27,7 +26,6 @@ import {
     MouseEvent as ReactMouseEvent,
     MutableRefObject,
     ReactElement,
-    RefCallback,
     SyntheticEvent,
     useImperativeHandle,
     useRef,
@@ -56,10 +54,8 @@ import {
 } from '../helper'
 import {
     CheckboxAdapter as Adapter,
-    CheckboxModel as Model,
     CheckboxProperties as Properties,
     CheckboxProps as Props,
-    CheckboxState as State,
     defaultModelState,
     DefaultCheckboxProperties as DefaultProperties,
     defaultCheckboxProperties as defaultProperties,
@@ -70,6 +66,13 @@ import {
 } from '../type'
 // endregion
 // region helper
+/**
+ * Derives validation state from provided properties and state.
+ * @param properties - Current component properties.
+ * @param currentState - Current component state.
+ *
+ * @returns Whether component is in an aggregated valid or invalid state.
+ */
 export function determineValidationState(
     properties:DefaultProperties, currentState:Partial<ModelState>
 ):boolean {
@@ -86,7 +89,6 @@ export function determineValidationState(
 // endregion
 /**
  * Validateable checkbox wrapper component.
- *
  * @property static:displayName - Descriptive name for component to show in web
  * developer tools.
  *
@@ -102,12 +104,12 @@ export function determineValidationState(
  * 4. All state changes except selection changes trigger an "onChange" event
  *    which delivers the consolidated properties object (with latest
  *    modifications included).
- *
  * @property static: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 const RequireableCheckboxInner = function(
@@ -117,12 +119,14 @@ export const RequireableCheckboxInner = function(
     /**
      * Calculate external properties (a set of all configurable properties).
      * @param properties - Properties to merge.
+     *
      * @returns External properties object.
      */
     const getConsolidatedProperties = (properties:Props):Properties => {
-        let result:DefaultProperties = mapPropertiesIntoModel<Props, DefaultProperties>(
-            properties, RequireableCheckbox.defaultProperties.model as Model
-        )
+        let result:DefaultProperties =
+            mapPropertiesIntoModel<Props, DefaultProperties>(
+                properties, RequireableCheckbox.defaultProperties.model
+            )
 
         determineValidationState(result, result.model.state)
 
@@ -137,12 +141,13 @@ export const RequireableCheckboxInner = function(
     /**
      * Triggered on blur events.
      * @param event - Event object.
+     *
      * @returns Nothing.
      */
     const onBlur = (event:SyntheticEvent):void => setValueState((
         oldValueState:ValueState
     ):ValueState => {
-        let changed:boolean = false
+        let changed = false
 
         if (oldValueState.modelState.focused) {
             properties.focused = false
@@ -179,6 +184,7 @@ export const RequireableCheckboxInner = function(
      * Triggered on any change events. Consolidates properties object and
      * triggers given on change callbacks.
      * @param event - Potential event object.
+     *
      * @returns Nothing.
      */
     const onChange = (event?:SyntheticEvent):void => {
@@ -201,6 +207,7 @@ export const RequireableCheckboxInner = function(
     /**
      * Triggered when ever the value changes.
      * @param event - Event object.
+     *
      * @returns Nothing.
      */
     const onChangeValue = (event:SyntheticEvent):void => {
@@ -215,7 +222,7 @@ export const RequireableCheckboxInner = function(
             if (oldValueState.value === properties.value)
                 return oldValueState
 
-            let stateChanged:boolean = false
+            let stateChanged = false
 
             const result:ValueState =
                 {...oldValueState, value: properties.value as boolean|null}
@@ -259,6 +266,7 @@ export const RequireableCheckboxInner = function(
     /**
      * Triggered on click events.
      * @param event - Mouse event object.
+     *
      * @returns Nothing.
      */
     const onClick = (event:ReactMouseEvent):void => {
@@ -271,6 +279,7 @@ export const RequireableCheckboxInner = function(
     /**
      * Triggered on focus events.
      * @param event - Focus event object.
+     *
      * @returns Nothing.
      */
     const onFocus = (event:ReactFocusEvent):void => {
@@ -283,11 +292,12 @@ export const RequireableCheckboxInner = function(
     /**
      * Triggers on start interacting with the input.
      * @param event - Event object which triggered interaction.
+     *
      * @returns Nothing.
      */
     const onTouch = (event:ReactFocusEvent|ReactMouseEvent):void =>
         setValueState((oldValueState:ValueState):ValueState => {
-            let changedState:boolean = false
+            let changedState = false
 
             if (!oldValueState.modelState.focused) {
                 properties.focused = true
@@ -335,7 +345,7 @@ export const RequireableCheckboxInner = function(
 
     const initialValue:boolean|null = determineInitialValue<boolean>(
         givenProps,
-        RequireableCheckbox.defaultProperties.model!.default,
+        RequireableCheckbox.defaultProperties.model.default,
         givenProps.checked
     )
     /*
@@ -386,6 +396,7 @@ export const RequireableCheckboxInner = function(
         setValueState =
             wrapStateSetter<ValueState>(setValueState, currentValueState)
     // endregion
+    // region export references
     useImperativeHandle(
         reference,
         ():Adapter & {
@@ -411,45 +422,48 @@ export const RequireableCheckboxInner = function(
         strict={RequireableCheckbox.strict}
         themeConfiguration={properties.themeConfiguration}
         tooltip={properties.tooltip}
-    ><div
-        className={[styles['requireable-checkbox']]
-            .concat(properties.className ?? [])
-            .join(' ')
-        }
-        style={properties.styles}
     >
-        <Checkbox
-            checked={Boolean(properties.value)}
-            disabled={properties.disabled}
-            foundationRef={foundationRef}
-            id={properties.id || properties.name}
-            indeterminate={properties.value === null}
-            inputRef={inputReference}
-            label={(
-                properties.invalid &&
-                (
-                    properties.showInitialValidationState ||
-                    /*
-                        Material inputs show their validation state at least
-                        after a blur event so we synchronize error appearances.
-                    */
-                    properties.visited
-                )
-            ) ?
-                <Theme use="error">
-                    {properties.description || properties.name}
-                </Theme> :
-                properties.description || properties.name
+        <div
+            className={[styles['requireable-checkbox']]
+                .concat(properties.className ?? [])
+                .join(' ')
             }
-            name={properties.name}
-            onBlur={onBlur}
-            onChange={onChangeValue}
-            onClick={onClick}
-            onFocus={onFocus}
-            ripple={properties.ripple}
-            value={`${properties.value}`}
-        />
-    </div></WrapConfigurations>
+            style={properties.styles}
+        >
+            <Checkbox
+                checked={Boolean(properties.value)}
+                disabled={properties.disabled}
+                foundationRef={foundationRef}
+                id={properties.id || properties.name}
+                indeterminate={properties.value === null}
+                inputRef={inputReference}
+                label={(
+                    properties.invalid &&
+                    (
+                        properties.showInitialValidationState ||
+                        /*
+                            Material inputs show their validation state at
+                            least after a blur event so we synchronize error
+                            appearances.
+                        */
+                        properties.visited
+                    )
+                ) ?
+                    <Theme use="error">
+                        {properties.description || properties.name}
+                    </Theme> :
+                    properties.description || properties.name
+                }
+                name={properties.name}
+                onBlur={onBlur}
+                onChange={onChangeValue}
+                onClick={onClick}
+                onFocus={onFocus}
+                ripple={properties.ripple}
+                value={`${properties.value as unknown as string}`}
+            />
+        </div>
+    </WrapConfigurations>
     // endregion
 } as ForwardRefRenderFunction<Adapter, Props>
 // NOTE: This is useful in react dev tools.
@@ -458,13 +472,14 @@ RequireableCheckboxInner.displayName = 'RequireableCheckbox'
  * Wrapping web component compatible react component.
  * @property static:defaultModelState - Initial model state.
  * @property static:defaultProperties - Initial property configuration.
- * @property static:propTypes - Triggers reacts runtime property value checks
+ * @property static:propTypes - Triggers reacts runtime property value checks.
  * @property static:strict - Indicates whether we should wrap render output in
  * reacts strict component.
  * @property static:wrapped - Wrapped component.
  *
  * @param props - Given components properties.
  * @param reference - Reference object to forward internal state.
+ *
  * @returns React elements.
  */
 export const RequireableCheckbox:CheckboxComponent =

package/components/WrapConfigurations.d.ts

@@ -5,6 +5,7 @@ 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.
@@ -12,11 +13,23 @@ import { ConfigurationProperties } from '../type';
  * @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;

package/components/WrapConfigurations.tsx

@@ -19,24 +19,24 @@
 // region imports
 import {AnyFunction, FirstParameter} from 'clientnode/type'
 import {
-    ComponentType,
     forwardRef,
     ForwardRefRenderFunction,
     FunctionComponent,
     MutableRefObject,
     ReactElement
 } from 'react'
-import {Theme, ThemeProviderProps} from '@rmwc/theme'
+import {Theme} from '@rmwc/theme'
 import {ThemePropT} from '@rmwc/types'
 
 import {WrapStrict} from './WrapStrict'
 import {WrapThemeProvider} from './WrapThemeProvider'
 import {WrapTooltip} from './WrapTooltip'
-import {ConfigurationProperties, Properties} from '../type'
-// endregion
+import {ConfigurationProperties} from '../type'
+//  endregion
 /**
  * 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.
@@ -44,6 +44,7 @@ import {ConfigurationProperties, Properties} from '../type'
  * @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 const WrapConfigurations:FunctionComponent<
@@ -56,7 +57,17 @@ export const WrapConfigurations:FunctionComponent<
             </WrapThemeProvider>
         </WrapTooltip>
     </WrapStrict>
-
+/**
+ * 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 function createWrapConfigurationsComponent<
     Type extends AnyFunction = AnyFunction, Reference = unknown
 >(
@@ -91,6 +102,7 @@ export function createWrapConfigurationsComponent<
             }
         </WrapConfigurations>
     }
+
     return options.withReference ?
         forwardRef(component as ForwardRefRenderFunction<typeof component>) :
         component

package/components/WrapStrict.d.ts

@@ -2,6 +2,12 @@ import { FunctionComponent } from 'react';
 import { Renderable } from '../type';
 /**
  * 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: Renderable;

package/components/WrapStrict.tsx

@@ -23,12 +23,19 @@ import {Renderable} from '../type'
 // endregion
 /**
  * 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 const WrapStrict:FunctionComponent<{
     children:Renderable
     strict:boolean
 }> = ({children, strict}):ReactElement =>
     strict ? <StrictMode>{children}</StrictMode> : <>{children}</>
+
 export default WrapStrict
 // region vim modline
 // vim: set tabstop=4 shiftwidth=4 expandtab:

package/components/WrapThemeProvider.d.ts

@@ -2,11 +2,13 @@ import { FunctionComponent, ReactElement } from 'react';
 import { ThemeProviderProps } from '@rmwc/theme';
 /**
  * Wraps a theme provider to given element if a configuration is provided.
- * @param children - Component or string to wrap.
- * @param configuration - Potential theme provider configuration.
- * @param 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.
+ * @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<{

package/components/WrapThemeProvider.tsx

@@ -22,11 +22,13 @@ import {ThemeProvider, ThemeProviderProps} from '@rmwc/theme'
 // endregion
 /**
  * Wraps a theme provider to given element if a configuration is provided.
- * @param children - Component or string to wrap.
- * @param configuration - Potential theme provider configuration.
- * @param 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.
+ * @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 const WrapThemeProvider:FunctionComponent<{
@@ -38,6 +40,7 @@ export const WrapThemeProvider:FunctionComponent<{
         {children}
     </ThemeProvider> :
     children
+
 export default WrapThemeProvider
 // region vim modline
 // vim: set tabstop=4 shiftwidth=4 expandtab:

package/components/WrapTooltip.d.ts

@@ -3,8 +3,10 @@ import { Properties } from '../type';
 /**
   * Wraps given component with a tooltip component with given tooltip
   * configuration.
-  * @param children - Component or string to wrap.
-  * @param options - Tooltip options.
+  * @param properties - Component provided properties.
+  * @param properties.children - Component or string to wrap.
+  * @param properties.options - Tooltip options.
+  *
   * @returns Wrapped given content.
  */
 export declare const WrapTooltip: FunctionComponent<{

package/components/WrapTooltip.tsx

@@ -26,8 +26,10 @@ import {Properties} from '../type'
 /**
   * Wraps given component with a tooltip component with given tooltip
   * configuration.
-  * @param children - Component or string to wrap.
-  * @param options - Tooltip options.
+  * @param properties - Component provided properties.
+  * @param properties.children - Component or string to wrap.
+  * @param properties.options - Tooltip options.
+  *
   * @returns Wrapped given content.
  */
 export const WrapTooltip:FunctionComponent<{
@@ -37,7 +39,10 @@ export const WrapTooltip:FunctionComponent<{
     if (typeof options === 'string')
         return <Tooltip
             content={<Typography use="caption">{options}</Typography>}
-        ><div className="generic-tooltip">{children}</div></Tooltip>
+        >
+            <div className="generic-tooltip">{children}</div>
+        </Tooltip>
+
     if (options !== null && typeof options === 'object') {
         if (typeof options.content === 'string')
             options = {
@@ -46,12 +51,15 @@ export const WrapTooltip:FunctionComponent<{
                     {options.content}
                 </Typography>
             }
-        return <Tooltip {...options}><div className="generic-tooltip">
-            {children}
-        </div></Tooltip>
+
+        return <Tooltip {...options}>
+            <div className="generic-tooltip">{children}</div>
+        </Tooltip>
     }
+
     return <>{children}</>
 }
+
 export default WrapTooltip
 // region vim modline
 // vim: set tabstop=4 shiftwidth=4 expandtab:

package/helper.d.ts

@@ -6,7 +6,6 @@ import { BaseProperties, BaseProps, DefaultBaseProperties, DefaultInputPropertie
 /**
  * Creates a mocked a state setter. Useful to dynamically convert a component
  * from uncontrolled to controlled.
- *
  * @param value - Parameter for state setter.
  *
  * @returns Nothing.
@@ -17,6 +16,7 @@ export declare const createDummyStateSetter: <Type = unknown>(value: Type) => Re
  * 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<unknown, ModelState> = ValueState<unknown, ModelState>>(properties: Properties, state: State) => Properties;
@@ -24,17 +24,15 @@ export declare const deriveMissingPropertiesFromState: <Properties extends BaseP
  * Creates a hybrid a state setter wich 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 = any>(setValueState: (value: Type | ((value: Type) => Type)) => void, currentValueState: Type) => ReturnType<typeof useState>[1];
+export declare const wrapStateSetter: <Type = any>(setValueState: (_value: Type | ((_value: Type) => Type)) => void, currentValueState: Type) => ReturnType<typeof useState>[1];
 /**
  * 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
@@ -50,6 +48,7 @@ export declare const triggerCallbackIfExists: <P extends Omit<BaseProperties, "m
 /**
  * Translate known symbols in a copied and return properties object.
  * @param properties - Object to translate.
+ *
  * @returns Transformed properties.
  */
 export declare const translateKnownSymbols: <Type = any>(properties: Mapping<typeof NullSymbol | typeof UndefinedSymbol | Type>) => Mapping<Type>;
@@ -58,6 +57,7 @@ export declare const translateKnownSymbols: <Type = any>(properties: Mapping<typ
  * @param properties - Components properties.
  * @param defaultValue - Internal fallback value.
  * @param alternateValue - Alternate value to respect.
+ *
  * @returns Determined value.
  */
 export declare const determineInitialValue: <Type = any>(properties: BaseProps, defaultValue?: Type | null | undefined, alternateValue?: Type | null | undefined) => Type | null;
@@ -67,6 +67,7 @@ export declare const determineInitialValue: <Type = any>(properties: BaseProps,
  * @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: <P extends DefaultBaseProperties = DefaultBaseProperties, MS extends Partial<ModelState> = Partial<ModelState>>(properties: P, currentState: MS, validators?: Mapping<() => boolean>) => boolean;
@@ -76,37 +77,67 @@ export declare const determineValidationState: <P extends DefaultBaseProperties
  * 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?: SelectProps['options'] | Array<{
     label?: string;
     value: unknown;
 }>): [Array<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?: SelectProps['options'] | Array<{
     label?: string;
     value: unknown;
 }>): 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: string, selection: SelectProps['options'] | Array<{
     label?: string;
     value: unknown;
 }>): null | T;
-export declare function normalizeSelection(selection?: Array<[string, string]> | SelectProps['options'] | Array<{
+/**
+ * Normalize given selection.
+ * @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 selection configuration.
+ */
+export declare function normalizeSelection(selection?: (Array<[string, string]> | SelectProps['options'] | Array<{
     label?: string;
     value: unknown;
-}>, labels?: Array<string> | Mapping): SelectProps['options'] | Array<{
+}>), labels?: Array<string> | Mapping): SelectProps['options'] | Array<{
     label?: string;
     value: unknown;
 }> | undefined;
 /**
  * Applies configured value transformations.
- *
  * @param configuration - Input configuration.
  * @param value - Value to transform.
  * @param transformer - To apply to given value.
@@ -116,7 +147,6 @@ export declare function normalizeSelection(selection?: Array<[string, string]> |
 export declare const parseValue: <T = unknown, P extends DefaultInputProperties<T> = DefaultInputProperties<T>, InputType = T>(configuration: P, value: InputType | null, transformer: InputDataTransformation) => T | null;
 /**
  * Represents configured value as string.
- *
  * @param configuration - Input configuration.
  * @param value - To represent.
  * @param transformer - To apply to given value.
@@ -127,7 +157,6 @@ export declare const parseValue: <T = unknown, P extends DefaultInputProperties<
 export declare function formatValue<T = unknown, P extends DefaultInputProperties<T> = DefaultInputProperties<T>>(configuration: P, value: null | T, transformer: InputDataTransformation, final?: boolean): string;
 /**
  * Determines initial value representation as string.
- *
  * @param properties - Components properties.
  * @param defaultProperties - Components default properties.
  * @param value - Current value to represent.
@@ -145,6 +174,7 @@ export declare function determineInitialRepresentation<T = unknown, P extends De
  * using previous constant complex object within a render function.
  * @param value - Value to memorize.
  * @param dependencies - Optional dependencies when to update given value.
+ *
  * @returns Given cached value.
  */
 export declare const useMemorizedValue: <T = unknown>(value: T, ...dependencies: Array<unknown>) => T;