carbon-react 103.2.0 → 104.2.0

package/lib/components/date/__internal__/utils.js

@@ -0,0 +1,182 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseDate = parseDate;
+exports.formatToISO = formatToISO;
+exports.formattedValue = formattedValue;
+exports.isDateValid = isDateValid;
+exports.additionalYears = additionalYears;
+exports.findMatchedFormatAndValue = findMatchedFormatAndValue;
+exports.parseISODate = parseISODate;
+exports.getDisabledDays = getDisabledDays;
+exports.checkISOFormatAndLength = checkISOFormatAndLength;
+exports.getSeparator = void 0;
+
+var _fp = require("date-fns/fp");
+
+function parseDate(formatString, valueString) {
+  if (!valueString || !formatString) return "";
+  return (0, _fp.parse)(new Date(), formatString, valueString);
+}
+
+function formatToISO(formatString, valueString) {
+  const dateValue = parseDate(formatString, valueString);
+
+  if (!isDateValid(dateValue)) {
+    return null;
+  }
+
+  return (0, _fp.formatISO)(dateValue).split("T")[0];
+}
+
+function formattedValue(formatString, value) {
+  return (0, _fp.format)(formatString, value);
+}
+
+function isDateValid(date) {
+  return date && date.toString() !== "Invalid Date";
+}
+
+function hasMatchedFormat(formatString, valueString) {
+  return formatString.length === valueString.length && (0, _fp.isMatch)(formatString, valueString);
+}
+
+function additionalYears(formatString, value) {
+  if (formatString.split("y").length - 1 !== 2) {
+    return [formatString, value];
+  }
+
+  let year = value.substring(value.length - 2);
+  const dayAndMonth = value.substring(0, value.length - 2);
+  const yearAsNumber = Number(year);
+
+  if (yearAsNumber < 69) {
+    year = String(2000 + yearAsNumber);
+  } else {
+    year = String(1900 + yearAsNumber);
+  }
+
+  return [`${formatString.substring(0, formatString.length - 2)}yyyy`, `${dayAndMonth}${year}`];
+}
+
+function makeSeparatedValues(arr, str) {
+  return arr.map((_, i) => str.substring(arr[i], arr[i + 1]));
+}
+
+function checkForCompleteMatch(formatArray, valueArray) {
+  return formatArray.every((formatString, i) => hasMatchedFormat(formatString, valueArray[i]));
+}
+
+function findMatchWithNoSeparators(valueString, formatString) {
+  const indexArray = formatString.split("").reduce((arr, char, index) => {
+    if (index === 0 || char !== formatString[index - 1]) {
+      return [...arr, index];
+    }
+
+    return arr;
+  }, []);
+  const formatArray = makeSeparatedValues(indexArray, formatString);
+  const valueArray = makeSeparatedValues(indexArray, valueString);
+
+  if (checkForCompleteMatch(formatArray, valueArray)) {
+    return [formatArray.join("."), valueArray.join(".")];
+  }
+
+  return null;
+}
+
+function findMatchWithSeparators(valueString, formatString, separator) {
+  const formatArray = formatString.split(separator);
+  const valueArray = valueString.split(separator);
+
+  if (checkForCompleteMatch(formatArray, valueArray)) {
+    return [formatString, valueString];
+  }
+
+  return null;
+}
+
+const getSeparator = value => {
+  const separator = ["", ".", ",", "-", "/", " ", ":"].slice(1).find(char => value.includes(char));
+  return separator || "";
+};
+
+exports.getSeparator = getSeparator;
+
+function findMatchedFormatAndValue(valueString, formats) {
+  if (!valueString) {
+    return ["", ""];
+  }
+
+  const valueSeparator = getSeparator(valueString);
+  const filteredFormats = formats.filter(formatString => formatString.length === valueString.length && getSeparator(formatString) === valueSeparator);
+  const matchedFormatAndValue = filteredFormats.reduce((acc, formatString) => {
+    const formatSeparator = getSeparator(formatString);
+
+    if (valueSeparator === "" && formatSeparator === "") {
+      // This check is added as there is a bug in date-fns https://github.com/date-fns/date-fns/issues/2785
+      // it incorrectly matches or fails to parse valid dates with no separators
+      const match = findMatchWithNoSeparators(valueString, formatString);
+
+      if (match) {
+        return match;
+      }
+    }
+
+    if (valueSeparator && formatSeparator && valueSeparator === formatSeparator) {
+      const match = findMatchWithSeparators(valueString, formatString, valueSeparator);
+
+      if (match) {
+        return match;
+      }
+    }
+
+    return acc;
+  }, []);
+  return matchedFormatAndValue;
+}
+
+function parseISODate(value) {
+  return (0, _fp.parseISO)(value);
+}
+/**
+ * Returns the disabled array of days specified by props maxDate and minDate
+ */
+
+
+function getDisabledDays(minDate, maxDate) {
+  const days = [];
+
+  if (!minDate && !maxDate) {
+    return null;
+  }
+
+  if (checkISOFormatAndLength(minDate)) {
+    days.push({
+      before: parseISODate(minDate)
+    });
+  }
+
+  if (checkISOFormatAndLength(maxDate)) {
+    days.push({
+      after: parseISODate(maxDate)
+    });
+  }
+
+  return days;
+}
+
+function checkISOFormatAndLength(value) {
+  if (!value || value.length !== 10 || !isValidISODate(value)) {
+    return false;
+  }
+
+  const array = value.split("-");
+  return array.length === 3 && array[0].length === 4 && array[1].length === 2 && array[2].length === 2;
+}
+
+function isValidISODate(dateString) {
+  return parseISODate(dateString).toString() !== "Invalid Date";
+}

package/lib/components/date/__internal__/weekday/weekday.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+
+export interface WeekdayProps {
+  className?: string;
+  title?: string;
+  children?: React.ReactNode;
+}
+
+declare function Weekday(
+  props: WeekdayProps & React.RefAttributes<HTMLElement>
+): JSX.Element;
+
+export default Weekday;

package/lib/components/date/{weekday → __internal__/weekday}/weekday.style.js

@@ -7,7 +7,7 @@ exports.default = void 0;
 
 var _styledComponents = _interopRequireDefault(require("styled-components"));
 
-var _base = _interopRequireDefault(require("../../../style/themes/base"));
+var _base = _interopRequireDefault(require("../../../../style/themes/base"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 

package/lib/components/date/date.component.d.ts

@@ -1,57 +1,29 @@
 export default DateInput;
-export const defaultDateFormat: "DD/MM/YYYY";
-export class BaseDateInput extends React.Component<any, any, any> {
-    constructor(props: Readonly<any>);
-    constructor(props: any, context?: any);
-    localeData: {
-        locale: any;
-        formats: any;
-        format: any;
-    };
-    isBlurBlocked: boolean;
-    isOpening: boolean;
-    inputHasFocus: any;
-    isControlled: boolean;
-    initialVisibleValue: any;
-    inputFocusedViaPicker: boolean;
-    hasMounted: boolean;
-    inputPresentationRef: React.RefObject<any>;
-    isAutoFocused: boolean | undefined;
-    hasValueChanged: (prevProps: any) => any;
-    assignInput: (input: any) => void;
-    input: any;
-    shouldAllowBlur: () => any;
-    shouldBlockBlur: () => boolean;
-    handleBlur: () => void;
-    handleFocus: (ev: any) => void;
-    handleKeyDown: (ev: any) => void;
-    openDatePicker: (openedOnMount: any) => void;
-    updateValidEventValues: (value: any) => void;
-    reformatVisibleDate: () => void;
-    closeDatePicker: () => void;
-    handleClick: (event: any) => void;
-    handleDateSelect: (selectedDate: any) => void;
-    updateVisibleValue: (date: any) => void;
-    focusInput: () => void;
-    handleVisibleInputChange: (ev: any) => void;
-    updateSelectedDate: (newValue: any) => void;
-    getDateObject: (newValue: any) => any;
-    emitOnChangeCallback: (ev: any, isoFormattedValue: any) => void;
-    canBeEmptyValues: (value: any) => any;
-    buildCustomEvent: (ev: any, isoFormattedValue: any) => any;
-    renderDatePicker: (dateRangeProps: any) => JSX.Element | null;
-    markCurrentDatepicker: () => void;
-    hiddenValue: () => any;
-    renderHiddenInput: () => JSX.Element;
+declare function DateInput({ adaptiveLabelBreakpoint, allowEmptyValue, autoFocus, "data-component": dataComponent, "data-element": dataElement, "data-role": dataRole, disabled, disablePortal, helpAriaLabel, labelInline, minDate, maxDate, onBlur, onChange, onClick, onFocus, onKeyDown, pickerProps, readOnly, size, tooltipPosition, value, ...rest }: {
+    [x: string]: any;
+    adaptiveLabelBreakpoint: any;
+    allowEmptyValue: any;
+    autoFocus: any;
+    "data-component": any;
+    "data-element": any;
+    "data-role": any;
+    disabled: any;
+    disablePortal?: boolean | undefined;
+    helpAriaLabel: any;
+    labelInline: any;
+    minDate: any;
+    maxDate: any;
+    onBlur: any;
+    onChange: any;
+    onClick: any;
+    onFocus: any;
+    onKeyDown: any;
+    pickerProps?: {} | undefined;
+    readOnly: any;
+    size?: string | undefined;
+    tooltipPosition: any;
+    value: any;
+}): JSX.Element;
+declare namespace DateInput {
+    const propTypes: any;
 }
-export namespace BaseDateInput {
-    export { LocaleContext as contextType };
-    export const propTypes: any;
-    export const defaultProps: {
-        disablePortal: boolean;
-        "data-component": string;
-    };
-}
-declare const DateInput: JSX.Element;
-import React from "react";
-import LocaleContext from "../../__internal__/i18n-context";