react-input-material 0.0.408 → 0.0.411

package/components/GenericInput.tsx

@@ -195,7 +195,6 @@ export const TINYMCE_DEFAULT_OPTIONS:Partial<TinyMCEOptions> = {
         'fullscreen',
         'link',
         'code',
-        'hr',
         'nonbreaking',
         'searchreplace',
         'visualblocks'
@@ -213,7 +212,7 @@ export const TINYMCE_DEFAULT_OPTIONS:Partial<TinyMCEOptions> = {
     `.trim(),
     toolbar2: `
         alignleft aligncenter alignright alignjustify outdent indent |
-        link hr nonbreaking bullist numlist bold italic underline strikethrough
+        link nonbreaking bullist numlist bold italic underline strikethrough
     `.trim(),
     trim: true
     /* eslint-enable camelcase */
@@ -1006,6 +1005,7 @@ export const GenericInputInner = function<Type = unknown>(
                 transformer,
                 /*
                     NOTE: Handle two cases:
+
                     1. Representation has to be determine initially
                        (-> usually no focus).
                     2. Representation was set from the outside
@@ -2142,6 +2142,7 @@ export const GenericInputInner = function<Type = unknown>(
                                     <Suspense fallback={
                                         <CircularProgress size="large" />
                                     }>
+                                        {/*TODO prevent on key enter propagation!*/}
                                         <CodeEditor
                                             {...genericProperties as
                                                 CodeEditorProps
@@ -2472,8 +2473,26 @@ GenericInput.transformer = {
     },
 
     date: {
-        format: {final: {transform: (value:number):string => {
-            value = typeof value === 'number' ? value : parseFloat(value)
+        format: {final: {transform: (
+            value:Date|number|string,
+            configuration:DefaultProperties<number>,
+            transformer:InputDataTransformation
+        ):string => {
+            if (typeof value !== 'number')
+                if (transformer.date.parse)
+                    value = transformer.date.parse(
+                        value, configuration, transformer
+                    )
+                else {
+                    const parsedDate:number = value instanceof Date ?
+                        value.getTime() / 1000 :
+                        Date.parse(value)
+                    if (isNaN(parsedDate)) {
+                        const parsedFloat:number = parseFloat(value as string)
+                        value = isNaN(parsedFloat) ? 0 : parsedFloat
+                    } else
+                        value = parsedDate / 1000
+                }
 
             if (value === Infinity)
                 return 'Infinitely far in the future'
@@ -2487,19 +2506,47 @@ GenericInput.transformer = {
 
             return formattedValue.substring(0, formattedValue.indexOf('T'))
         }}},
-        parse: (value:Date|number|string):number =>
-            typeof value === 'number' ?
-                value :
-                value instanceof Date ?
-                    value.getTime() / 1000 :
-                    isNaN(Date.parse(value)) ?
-                        parseFloat(value) :
-                        Date.parse(value) / 1000
+        parse: (value:Date|number|string):number => {
+            if (typeof value === 'number')
+                return value
+
+            if (value instanceof Date)
+                return value.getTime() / 1000
+
+            const parsedDate:number = Date.parse(value)
+            if (isNaN(parsedDate)) {
+                const parsedFloat:number = parseFloat(value)
+                if (isNaN(parsedFloat))
+                    return 0
+
+                return parsedFloat
+            }
+
+            return parsedDate / 1000
+        }
     },
     // TODO respect local to utc conversion.
     'datetime-local': {
-        format: {final: {transform: (value:number):string => {
-            value = typeof value === 'number' ? value : parseFloat(value)
+        format: {final: {transform: (
+            value:Date|number|string,
+            configuration:DefaultProperties<number>,
+            transformer:InputDataTransformation
+        ):string => {
+            if (typeof value !== 'number')
+                if (transformer['datetime-local'].parse)
+                    value = transformer['datetime-local'].parse(
+                        value, configuration, transformer
+                    )
+                else {
+                    const parsedDate:number = value instanceof Date ?
+                        value.getTime() / 1000 :
+                        Date.parse(value)
+                    if (isNaN(parsedDate)) {
+                        const parsedFloat:number = parseFloat(value as string)
+                        value = isNaN(parsedFloat) ? 0 : parsedFloat
+                    } else
+                        value = parsedDate / 1000
+                }
 
             if (value === Infinity)
                 return 'Infinitely far in the future'
@@ -2514,72 +2561,116 @@ GenericInput.transformer = {
             return formattedValue.substring(0, formattedValue.length - 1)
         }}},
         parse: (
-            value:number|string,
+            value:Date|number|string,
             configuration:DefaultProperties<number>,
             transformer:InputDataTransformation
-        ):number =>
-            transformer.date.parse ?
-                transformer.date.parse(value, configuration, transformer) :
-                isNaN(Date.parse(value as string)) ?
-                    0 :
-                    Date.parse(value as string) / 1000
+        ):number => {
+            if (transformer.date.parse)
+                return transformer.date.parse(
+                    value, configuration, transformer
+                )
+
+            if (value instanceof Date)
+                return value.getTime() / 1000
+
+            const parsedDate:number = Date.parse(value as string)
+            if (isNaN(parsedDate)) {
+                const parsedFloat:number = parseFloat(value as string)
+                if (isNaN(parsedFloat))
+                    return 0
+
+                return parsedFloat
+            }
+
+            return parsedDate / 1000
+        }
     },
     time: {
-        format: {final: {transform: (
-            value:number, configuration:DefaultProperties<number>
-        ):string => {
-            value = typeof value === 'number' ? value : parseFloat(value)
+        format: {
+            final: {transform: (
+                value:Date|number|string,
+                configuration:DefaultProperties<number>,
+                transformer:InputDataTransformation
+            ):string => {
+                if (typeof value !== 'number')
+                    if (transformer.time.parse)
+                        value = transformer.time.parse(
+                            value, configuration, transformer
+                        )
+                    else {
+                        const parsedDate:number = value instanceof Date ?
+                            value.getTime() / 1000 :
+                            Date.parse(value)
+                        if (isNaN(parsedDate)) {
+                            const parsedFloat:number =
+                                parseFloat(value as string)
+                            value = isNaN(parsedFloat) ? 0 : parsedFloat
+                        } else
+                            value = parsedDate / 1000
+                    }
 
-            if (value === Infinity)
-                return 'Infinitely far in the future'
-            if (value === -Infinity)
-                return 'Infinitely early in the past'
-            if (!isFinite(value))
-                return ''
+                if (value === Infinity)
+                    return 'Infinitely far in the future'
+                if (value === -Infinity)
+                    return 'Infinitely early in the past'
+                if (!isFinite(value))
+                    return ''
 
-            let formattedValue:string =
-                (new Date(Math.round(value * 1000))).toISOString()
+                let formattedValue:string =
+                    (new Date(Math.round(value * 1000))).toISOString()
 
-            formattedValue = formattedValue.substring(
-                formattedValue.indexOf('T') + 1, formattedValue.length - 1
-            )
+                formattedValue = formattedValue.substring(
+                    formattedValue.indexOf('T') + 1, formattedValue.length - 1
+                )
 
-            if (
-                configuration.step &&
-                configuration.step >= 60 &&
-                (configuration.step % 60) === 0
-            )
-                return formattedValue.substring(
-                    0, formattedValue.lastIndexOf(':')
+                if (
+                    configuration.step &&
+                    configuration.step >= 60 &&
+                    (configuration.step % 60) === 0
                 )
+                    return formattedValue.substring(
+                        0, formattedValue.lastIndexOf(':')
+                    )
 
-            return formattedValue
-        }}},
-        parse: (value:Date|number|string):number =>
-            typeof value === 'number' ?
-                value :
-                value instanceof Date ?
-                    value.getTime() / 1000 :
-                    isNaN(Date.parse(value)) ?
-                        parseFloat(value.replace(
-                            /^([0-9]{2}):([0-9]{2})(:([0-9]{2}(\.[0-9]+)?))?$/,
-                            (
-                                _match:string,
-                                hour:string,
-                                minute:string,
-                                secondsSuffix?:string,
-                                seconds?:string,
-                                _millisecondsSuffix?:string
-                            ):string =>
-                                String(
-                                    parseInt(hour) *
-                                    60 ** 2 +
-                                    parseInt(minute) *
-                                    60 +
-                                    (secondsSuffix ? parseFloat(seconds!) : 0)
-                                )
-                        )) :
-                        Date.parse(value) / 1000
+                return formattedValue
+            }}
+        },
+        parse: (value:Date|number|string):number => {
+            if (typeof value === 'number')
+                return value
+
+            if (value instanceof Date)
+                return value.getTime() / 1000
+
+            const parsedDate:number = Date.parse(value)
+            if (isNaN(parsedDate)) {
+                const parsedFloat:number = parseFloat(value.replace(
+                    /^([0-9]{2}):([0-9]{2})(:([0-9]{2}(\.[0-9]+)?))?$/,
+                    (
+                        _match:string,
+                        hour:string,
+                        minute:string,
+                        secondsSuffix?:string,
+                        seconds?:string,
+                        _millisecondsSuffix?:string
+                    ):string =>
+                        String(
+                            parseInt(hour) *
+                            60 ** 2 +
+                            parseInt(minute) *
+                            60 +
+                            (secondsSuffix ? parseFloat(seconds!) : 0)
+                        )
+                ))
+
+                if (isNaN(parsedFloat))
+                    return 0
+
+                return parsedFloat
+            }
+
+            return parsedDate / 1000
+        }
     },
 
     float: {