@synerise/ds-factors 1.11.11 → 1.11.12

package/dist/FactorValue/Array/Array.utils.js

@@ -1,25 +1,28 @@
-import { v4 as uuid } from 'uuid';
-export var matchesSearchQuery = function matchesSearchQuery(item, searchQuery) {
+import { v4 } from "uuid";
+const matchesSearchQuery = (item, searchQuery) => {
   return String(item).toLocaleLowerCase().includes(searchQuery.toLocaleLowerCase());
 };
-export var arrayWithUUID = function arrayWithUUID(items) {
-  return items.map(function (item) {
-    return {
-      value: item,
-      id: uuid()
-    };
-  });
+const arrayWithUUID = (items) => {
+  return items.map((item) => ({
+    value: item,
+    id: v4()
+  }));
 };
-export var sanitiseValues = function sanitiseValues(element) {
+const sanitiseValues = (element) => {
   return element.trim();
 };
-export var isNumberAsString = function isNumberAsString(value) {
-  return sanitiseValues(value) === "" + parseFloat(sanitiseValues(value));
+const isNumberAsString = (value) => {
+  return sanitiseValues(value) === `${parseFloat(sanitiseValues(value))}`;
 };
-export var isArrayOfNumbersAsString = function isArrayOfNumbersAsString(array) {
-  var sanitisedArray = array.map(sanitiseValues);
-  var comparisonArray = array.map(function (item) {
-    return "" + parseFloat(sanitiseValues(item));
-  });
+const isArrayOfNumbersAsString = (array) => {
+  const sanitisedArray = array.map(sanitiseValues);
+  const comparisonArray = array.map((item) => `${parseFloat(sanitiseValues(item))}`);
   return JSON.stringify(sanitisedArray) === JSON.stringify(comparisonArray);
-};
+};
+export {
+  arrayWithUUID,
+  isArrayOfNumbersAsString,
+  isNumberAsString,
+  matchesSearchQuery,
+  sanitiseValues
+};

package/dist/FactorValue/Array/components/ArrayCollector.d.ts

@@ -1,3 +1,3 @@
-import React from 'react';
-import { type ArrayCollectorProps } from '../Array.types';
+import { default as React } from 'react';
+import { ArrayCollectorProps } from '../Array.types';
 export declare const ArrayCollector: <ItemType extends "string" | "number">({ limit, itemType, arrayValueCount, texts, onConfirm, collectorSuggestions, }: ArrayCollectorProps<ItemType>) => React.JSX.Element;

package/dist/FactorValue/Array/components/ArrayCollector.js

@@ -1,113 +1,89 @@
-import React, { useEffect, useState } from 'react';
-import { v4 as uuid } from 'uuid';
-import Collector from '@synerise/ds-collector';
-import { COMMA } from '../Array.const';
-import * as S from '../Array.styles';
-import { isArrayOfNumbersAsString, isNumberAsString, sanitiseValues } from '../Array.utils';
-import { useCollector } from '../hooks/useCollector';
-export var ArrayCollector = function ArrayCollector(_ref) {
-  var limit = _ref.limit,
-    itemType = _ref.itemType,
-    arrayValueCount = _ref.arrayValueCount,
-    texts = _ref.texts,
-    onConfirm = _ref.onConfirm,
-    collectorSuggestions = _ref.collectorSuggestions;
-  var _useState = useState([]),
-    collectorValues = _useState[0],
-    setCollectorValues = _useState[1];
-  var _useCollector = useCollector({
-      limit: limit,
-      collectorCount: collectorValues.length,
-      arrayValueCount: arrayValueCount,
-      texts: texts
-    }),
-    disabled = _useCollector.disabled,
-    error = _useCollector.error,
-    errorMessage = _useCollector.errorMessage,
-    addEnabled = _useCollector.addEnabled,
-    setHasTypeError = _useCollector.setHasTypeError,
-    exceedsLimit = _useCollector.exceedsLimit;
-  useEffect(function () {
-    if (itemType === 'number') {
-      var plainValues = collectorValues.map(function (item) {
-        return sanitiseValues(item.value);
-      });
+import { jsx } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { v4 } from "uuid";
+import Collector from "@synerise/ds-collector";
+import { COMMA } from "../Array.const.js";
+import { CollectorWrapper } from "../Array.styles.js";
+import { sanitiseValues, isArrayOfNumbersAsString, isNumberAsString } from "../Array.utils.js";
+import { useCollector } from "../hooks/useCollector.js";
+const ArrayCollector = ({
+  limit,
+  itemType,
+  arrayValueCount,
+  texts,
+  onConfirm,
+  collectorSuggestions
+}) => {
+  const [collectorValues, setCollectorValues] = useState([]);
+  const {
+    disabled,
+    error,
+    errorMessage,
+    addEnabled,
+    setHasTypeError,
+    exceedsLimit
+  } = useCollector({
+    limit,
+    collectorCount: collectorValues.length,
+    arrayValueCount,
+    texts
+  });
+  useEffect(() => {
+    if (itemType === "number") {
+      const plainValues = collectorValues.map((item) => sanitiseValues(item.value));
       setHasTypeError(!isArrayOfNumbersAsString(plainValues));
     }
   }, [collectorValues, setHasTypeError, itemType]);
-  var handleCancel = function handleCancel() {
+  const handleCancel = () => {
     setCollectorValues([]);
   };
-  var handleConfirm = function handleConfirm(items) {
-    var hasError = items.some(function (item) {
-      return item.hasError;
-    });
-    var hasExceededLimit = exceedsLimit(items.length);
+  const handleConfirm = (items) => {
+    const hasError = items.some((item) => item.hasError);
+    const hasExceededLimit = exceedsLimit(items.length);
     if (!hasError && !hasExceededLimit) {
-      var rawItemValues = items.map(function (item) {
-        return {
-          value: itemType === 'number' ? Number(item.value) : item.value,
-          id: item.id
-        };
-      });
+      const rawItemValues = items.map((item) => ({
+        value: itemType === "number" ? Number(item.value) : item.value,
+        id: item.id
+      }));
       onConfirm(rawItemValues);
       setCollectorValues([]);
     } else {
       setCollectorValues(items);
     }
   };
-  var handleItemAdd = function handleItemAdd(text) {
+  const handleItemAdd = (text) => {
     return {
-      value: sanitiseValues("" + text),
+      value: sanitiseValues(`${text}`),
       type: itemType,
-      hasError: itemType === 'number' && !isNumberAsString("" + text),
-      id: uuid()
+      hasError: itemType === "number" && !isNumberAsString(`${text}`),
+      id: v4()
     };
   };
-  var handleItemSelect = function handleItemSelect(item) {
-    setCollectorValues([].concat(collectorValues, [item]));
+  const handleItemSelect = (item) => {
+    setCollectorValues([...collectorValues, item]);
   };
-  var handleItemDeselect = function handleItemDeselect(deselectedItem) {
-    setCollectorValues(collectorValues.filter(function (collectorItem) {
-      return collectorItem.id !== deselectedItem.id;
-    }));
+  const handleItemDeselect = (deselectedItem) => {
+    setCollectorValues(collectorValues.filter((collectorItem) => collectorItem.id !== deselectedItem.id));
   };
-  var handleMultipleItemSelect = function handleMultipleItemSelect(items) {
-    setCollectorValues([].concat(collectorValues, items));
+  const handleMultipleItemSelect = (items) => {
+    setCollectorValues([...collectorValues, ...items]);
   };
-  return /*#__PURE__*/React.createElement(S.CollectorWrapper, null, /*#__PURE__*/React.createElement(Collector, {
-    valuesSeparator: COMMA,
-    error: error,
-    errorText: errorMessage,
-    onConfirm: addEnabled ? handleConfirm : undefined,
-    onItemSelect: handleItemSelect,
-    onMultipleItemsSelect: handleMultipleItemSelect,
-    selected: collectorValues,
-    onCancel: handleCancel,
-    onItemAdd: handleItemAdd,
-    allowCustomValue: true,
-    disabled: disabled,
-    cancelButtonProps: {
-      'data-testid': 'array-collector-cancel-button'
-    },
-    addButtonProps: addEnabled ? {
-      'data-testid': 'array-collector-add-button'
-    } : {
-      disabled: true,
-      'data-testid': 'array-collector-add-button'
-    },
-    allowMultipleValues: true,
-    lookupConfig: {
-      display: 'value',
-      filter: 'value'
-    },
-    onItemDeselect: handleItemDeselect,
-    allowPaste: true,
-    suggestions: collectorSuggestions || [],
-    texts: {
-      add: texts.array.collectorAdd,
-      placeholder: texts.array.collectorPlaceholder,
-      cancel: texts.array.collectorCancel
-    }
-  }));
-};
+  return /* @__PURE__ */ jsx(CollectorWrapper, { children: /* @__PURE__ */ jsx(Collector, { valuesSeparator: COMMA, error, errorText: errorMessage, onConfirm: addEnabled ? handleConfirm : void 0, onItemSelect: handleItemSelect, onMultipleItemsSelect: handleMultipleItemSelect, selected: collectorValues, onCancel: handleCancel, onItemAdd: handleItemAdd, allowCustomValue: true, disabled, cancelButtonProps: {
+    "data-testid": "array-collector-cancel-button"
+  }, addButtonProps: addEnabled ? {
+    "data-testid": "array-collector-add-button"
+  } : {
+    disabled: true,
+    "data-testid": "array-collector-add-button"
+  }, allowMultipleValues: true, lookupConfig: {
+    display: "value",
+    filter: "value"
+  }, onItemDeselect: handleItemDeselect, allowPaste: true, suggestions: collectorSuggestions || [], texts: {
+    add: texts.array.collectorAdd,
+    placeholder: texts.array.collectorPlaceholder,
+    cancel: texts.array.collectorCancel
+  } }) });
+};
+export {
+  ArrayCollector
+};

package/dist/FactorValue/Array/components/ArrayCreator.d.ts

@@ -1,3 +1,3 @@
-import React from 'react';
-import type { ArrayCreatorProps } from '../Array.types';
+import { default as React } from 'react';
+import { ArrayCreatorProps } from '../Array.types';
 export declare const ArrayCreator: <ItemType extends "string" | "number">({ value: arrayValue, searchQuery, itemType, onValueChange, limit, readOnly, texts, collectorSuggestions, }: ArrayCreatorProps<ItemType>) => React.JSX.Element;

package/dist/FactorValue/Array/components/ArrayCreator.js

@@ -1,81 +1,49 @@
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-import React, { useMemo } from 'react';
-import { CloseM, InboxNoResultsL } from '@synerise/ds-icon';
-import { Input } from '@synerise/ds-input';
-import InputNumber from '@synerise/ds-input-number';
-import Tooltip from '@synerise/ds-tooltip';
-import * as S from '../Array.styles';
-import { matchesSearchQuery } from '../Array.utils';
-import { ArrayCollector } from './ArrayCollector';
-export var ArrayCreator = function ArrayCreator(_ref) {
-  var _ref$value = _ref.value,
-    arrayValue = _ref$value === void 0 ? [] : _ref$value,
-    searchQuery = _ref.searchQuery,
-    itemType = _ref.itemType,
-    onValueChange = _ref.onValueChange,
-    limit = _ref.limit,
-    readOnly = _ref.readOnly,
-    texts = _ref.texts,
-    collectorSuggestions = _ref.collectorSuggestions;
-  var arrayReversed = useMemo(function () {
-    return [].concat(arrayValue).reverse();
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { CloseM, InboxNoResultsL } from "@synerise/ds-icon";
+import { Input } from "@synerise/ds-input";
+import InputNumber from "@synerise/ds-input-number";
+import Tooltip from "@synerise/ds-tooltip";
+import { ModalContentWrapper, CreatorItemsList, CreatorRow, DeleteIcon, EmptyState } from "../Array.styles.js";
+import { matchesSearchQuery } from "../Array.utils.js";
+import { ArrayCollector } from "./ArrayCollector.js";
+const ArrayCreator = ({
+  value: arrayValue = [],
+  searchQuery,
+  itemType,
+  onValueChange,
+  limit,
+  readOnly,
+  texts,
+  collectorSuggestions
+}) => {
+  const arrayReversed = useMemo(() => {
+    return [...arrayValue].reverse();
   }, [arrayValue]);
-  var handleItemChange = function handleItemChange(valueIndex, newValue) {
-    var updatedArray = arrayReversed.map(function (currentValue, index) {
-      return index === valueIndex ? _extends({}, currentValue, {
-        value: newValue
-      }) : currentValue;
-    }).reverse();
+  const handleItemChange = (valueIndex, newValue) => {
+    const updatedArray = arrayReversed.map((currentValue, index) => index === valueIndex ? {
+      ...currentValue,
+      value: newValue
+    } : currentValue).reverse();
     onValueChange(updatedArray);
   };
-  var handleItemRemove = function handleItemRemove(valueIndex) {
-    onValueChange([].concat(arrayReversed.slice(0, valueIndex), arrayReversed.slice(valueIndex + 1)).reverse());
+  const handleItemRemove = (valueIndex) => {
+    onValueChange([...arrayReversed.slice(0, valueIndex), ...arrayReversed.slice(valueIndex + 1)].reverse());
   };
-  var handleConfirm = function handleConfirm(rawItemValues) {
-    onValueChange([].concat(arrayValue, rawItemValues));
+  const handleConfirm = (rawItemValues) => {
+    onValueChange([...arrayValue, ...rawItemValues]);
   };
-  var filteredItems = useMemo(function () {
-    return searchQuery ? arrayReversed.filter(function (item) {
-      return matchesSearchQuery(item.value, searchQuery);
-    }) : arrayReversed;
+  const filteredItems = useMemo(() => {
+    return searchQuery ? arrayReversed.filter((item) => matchesSearchQuery(item.value, searchQuery)) : arrayReversed;
   }, [searchQuery, arrayReversed]);
-  return /*#__PURE__*/React.createElement(S.ModalContentWrapper, null, /*#__PURE__*/React.createElement(React.Fragment, null, !readOnly && /*#__PURE__*/React.createElement(ArrayCollector, {
-    arrayValueCount: arrayValue.length,
-    limit: limit,
-    itemType: itemType,
-    onConfirm: handleConfirm,
-    texts: texts,
-    collectorSuggestions: collectorSuggestions
-  }), filteredItems != null && filteredItems.length ? /*#__PURE__*/React.createElement(S.CreatorItemsList, null, filteredItems.map(function (item, index) {
-    return /*#__PURE__*/React.createElement(S.CreatorRow, {
-      "data-testid": "ds-factors-array-item",
-      key: item.id
-    }, itemType === 'string' ? /*#__PURE__*/React.createElement(Input, {
-      resetMargin: true,
-      readOnly: readOnly,
-      onChange: function onChange(event) {
-        return handleItemChange(index, event.target.value);
-      },
-      value: item.value
-    }) : /*#__PURE__*/React.createElement(InputNumber, {
-      raw: true,
-      readOnly: readOnly,
-      onChange: function onChange(changedValue) {
-        return changedValue && handleItemChange(index, changedValue);
-      },
-      value: item.value
-    }), !readOnly && /*#__PURE__*/React.createElement(Tooltip, {
-      title: texts.array.deleteItemTooltip
-    }, /*#__PURE__*/React.createElement(S.DeleteIcon, {
-      "data-testid": "ds-factors-array-remove-item",
-      onClick: function onClick() {
-        return handleItemRemove(index);
-      },
-      component: /*#__PURE__*/React.createElement(CloseM, null)
-    })));
-  })) : /*#__PURE__*/React.createElement(S.EmptyState, {
-    customIcon: /*#__PURE__*/React.createElement(InboxNoResultsL, null),
-    text: searchQuery ? texts.array.emptyResultsTitle : texts.array.emptyTitle,
-    label: searchQuery ? texts.array.emptyResultsDescription : texts.array.emptyDescription
-  })));
-};
+  return /* @__PURE__ */ jsx(ModalContentWrapper, { children: /* @__PURE__ */ jsxs(Fragment, { children: [
+    !readOnly && /* @__PURE__ */ jsx(ArrayCollector, { arrayValueCount: arrayValue.length, limit, itemType, onConfirm: handleConfirm, texts, collectorSuggestions }),
+    filteredItems?.length ? /* @__PURE__ */ jsx(CreatorItemsList, { children: filteredItems.map((item, index) => /* @__PURE__ */ jsxs(CreatorRow, { "data-testid": "ds-factors-array-item", children: [
+      itemType === "string" ? /* @__PURE__ */ jsx(Input, { resetMargin: true, readOnly, onChange: (event) => handleItemChange(index, event.target.value), value: item.value }) : /* @__PURE__ */ jsx(InputNumber, { raw: true, readOnly, onChange: (changedValue) => changedValue && handleItemChange(index, changedValue), value: item.value }),
+      !readOnly && /* @__PURE__ */ jsx(Tooltip, { title: texts.array.deleteItemTooltip, children: /* @__PURE__ */ jsx(DeleteIcon, { "data-testid": "ds-factors-array-remove-item", onClick: () => handleItemRemove(index), component: /* @__PURE__ */ jsx(CloseM, {}) }) })
+    ] }, item.id)) }) : /* @__PURE__ */ jsx(EmptyState, { customIcon: /* @__PURE__ */ jsx(InboxNoResultsL, {}), text: searchQuery ? texts.array.emptyResultsTitle : texts.array.emptyTitle, label: searchQuery ? texts.array.emptyResultsDescription : texts.array.emptyDescription })
+  ] }) });
+};
+export {
+  ArrayCreator
+};

package/dist/FactorValue/Array/components/ArrayLimit.d.ts

@@ -1,3 +1,3 @@
-import React from 'react';
-import { type ArrayLimitProps } from '../Array.types';
+import { default as React } from 'react';
+import { ArrayLimitProps } from '../Array.types';
 export declare const ArrayLimit: ({ limit, count, texts }: ArrayLimitProps) => React.JSX.Element;

package/dist/FactorValue/Array/components/ArrayLimit.js

@@ -1,14 +1,16 @@
-import React from 'react';
-import { IconAlert } from '@synerise/ds-alert';
-import * as S from '../Array.styles';
-export var ArrayLimit = function ArrayLimit(_ref) {
-  var limit = _ref.limit,
-    _ref$count = _ref.count,
-    count = _ref$count === void 0 ? 0 : _ref$count,
-    texts = _ref.texts;
-  return /*#__PURE__*/React.createElement(S.Limit, null, /*#__PURE__*/React.createElement(S.LimitPart, null, count === limit ? /*#__PURE__*/React.createElement(IconAlert, {
-    iconAlert: true,
-    type: "warning",
-    message: texts.array.limitReached
-  }) : texts.array.limitPrefix), /*#__PURE__*/React.createElement(S.LimitPart, null, " " + count + "/" + limit));
-};
+import { jsxs, jsx } from "react/jsx-runtime";
+import { IconAlert } from "@synerise/ds-alert";
+import { Limit, LimitPart } from "../Array.styles.js";
+const ArrayLimit = ({
+  limit,
+  count = 0,
+  texts
+}) => {
+  return /* @__PURE__ */ jsxs(Limit, { children: [
+    /* @__PURE__ */ jsx(LimitPart, { children: count === limit ? /* @__PURE__ */ jsx(IconAlert, { iconAlert: true, type: "warning", message: texts.array.limitReached }) : texts.array.limitPrefix }),
+    /* @__PURE__ */ jsx(LimitPart, { children: ` ${count}/${limit}` })
+  ] });
+};
+export {
+  ArrayLimit
+};

package/dist/FactorValue/Array/components/ArrayModal.d.ts

@@ -1,3 +1,3 @@
-import React from 'react';
-import { type ArrayModalProps } from '../Array.types';
+import { default as React } from 'react';
+import { ArrayModalProps } from '../Array.types';
 export declare const ArrayModal: <ItemType extends "string" | "number">({ value, itemType, onApply, onCancel, visible, readOnly, texts, limit, collectorSuggestions, }: ArrayModalProps<ItemType>) => React.JSX.Element;