@dfds-ui/forms 2.2.0-alpha.74ddaa53 → 2.2.0-alpha.7bc14dd5

package/cjs/rating/Rating.d.ts

@@ -0,0 +1,54 @@
+import React from 'react';
+import { FieldWrapProps } from '../field-wrap/FieldWrap';
+import { Size } from '../types';
+export type RatingProps = {
+    ref?: React.Ref<HTMLInputElement>;
+    /**
+     * Amount of related checkboxes
+     */
+    rangeCardinality: number;
+    /**
+     * Name for the checkbox group
+     */
+    name: string;
+    /**
+     * Hint text on the left
+     */
+    leadingHint?: string;
+    /**
+     * Hint text on the right
+     */
+    trailingHint?: string;
+    /**
+     * Labels on top of the radio selectors, a string returning function called with the selector's index
+     */
+    scaleLabels?: (index: number) => string;
+    /**
+     * If used as a controlled component, this value sets the selected radio
+     */
+    value?: number;
+    /**
+     * Initial selected value
+     */
+    defaultValue?: number;
+    /**
+     * Callback when the user changes the selected value
+     */
+    onChange?: (index: number, event: React.ChangeEvent<HTMLInputElement>) => void;
+    disabled?: boolean;
+    showScaleLabels?: boolean;
+    /**
+     * When this property is `true`, it styles the radios to the left of the selected as `checked`
+     */
+    cumulative?: boolean;
+    Icon?: (index: number) => React.ComponentType;
+};
+export declare const Rating: ({ rangeCardinality, name, leadingHint, trailingHint, scaleLabels, onChange, value, disabled, showScaleLabels, cumulative, defaultValue, Icon, ref, }: RatingProps) => React.JSX.Element;
+export type RatingFieldProps = RatingProps & Omit<FieldWrapProps, 'size' | 'placeholder' | 'helpPlacement' | 'children'> & {
+    size: Exclude<Size, 'large'>;
+};
+/**
+ * The `RatingField` component will allow the user to provide feedback by ranking things on a specified scale.
+ */
+export declare const RatingField: ({ name, label, size, errorMessage, assistiveText, hideAsterisk, required, rangeCardinality, scaleLabels, leadingHint, trailingHint, extraAssistiveText, cumulative, value, help, disabled, onChange, showScaleLabels, defaultValue, Icon, className, ref, }: RatingFieldProps) => React.JSX.Element;
+export default RatingField;

package/cjs/rating/Rating.js

@@ -0,0 +1,211 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.RatingField = exports.Rating = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _flexbox = require("@dfds-ui/react-components/flexbox");
+var _react2 = require("@emotion/react");
+var _radio = require("../radio");
+var _typography = require("@dfds-ui/typography");
+var _FieldWrap = require("../field-wrap/FieldWrap");
+var _theme = require("@dfds-ui/theme");
+var _jsxRuntime = require("@emotion/react/jsx-runtime");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+const scaleSpacingCss = process.env.NODE_ENV === "production" ? {
+  name: "18cky5w",
+  styles: "width:1.5rem;margin-right:1rem;margin-left:0;margin-top:0"
+} : {
+  name: "vdgx3w-scaleSpacingCss",
+  styles: "width:1.5rem;margin-right:1rem;margin-left:0;margin-top:0;label:scaleSpacingCss;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/rating/Rating.tsx"],"names":[],"mappings":"AAS2B","file":"../../../src/rating/Rating.tsx","sourcesContent":["import React, { ReactNode, useMemo, useState } from 'react'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\nimport { css } from '@emotion/react'\nimport { Radio, RadioStyleState } from '../radio'\nimport { Text } from '@dfds-ui/typography'\nimport { FieldWrap, FieldWrapProps } from '../field-wrap/FieldWrap'\nimport { theme } from '@dfds-ui/theme'\nimport { Size } from '../types'\n\nconst scaleSpacingCss = css`\n  width: 1.5rem;\n  margin-right: 1rem;\n  margin-left: 0;\n  margin-top: 0;\n`\n\nconst scaleLabelsSpacingCss = css`\n  margin-bottom: 0.5rem;\n  padding-top: 0.5rem;\n`\n\nconst RatingHint = ({ children, side }: { children: ReactNode; side: 'leading' | 'trailing' }) => {\n  return (\n    <Text\n      as=\"span\"\n      styledAs=\"bodyInterface\"\n      css={css`\n        padding-bottom: 0.5rem;\n        color: ${theme.colors.text.dark.secondary};\n        ${side === 'leading' ? `margin-right: 1rem;` : 'margin-left: 1rem;'}\n      `}\n    >\n      {children}\n    </Text>\n  )\n}\n\nexport type RatingProps = {\n  ref?: React.Ref<HTMLInputElement>\n  /**\n   * Amount of related checkboxes\n   */\n  rangeCardinality: number\n  /**\n   * Name for the checkbox group\n   */\n  name: string\n  /**\n   * Hint text on the left\n   */\n  leadingHint?: string\n  /**\n   * Hint text on the right\n   */\n  trailingHint?: string\n  /**\n   * Labels on top of the radio selectors, a string returning function called with the selector's index\n   */\n  scaleLabels?: (index: number) => string\n  /**\n   * If used as a controlled component, this value sets the selected radio\n   */\n  value?: number\n  /**\n   * Initial selected value\n   */\n  defaultValue?: number\n  /**\n   * Callback when the user changes the selected value\n   */\n  onChange?: (index: number, event: React.ChangeEvent<HTMLInputElement>) => void\n  disabled?: boolean\n  showScaleLabels?: boolean\n  /**\n   * When this property is `true`, it styles the radios to the left of the selected as `checked`\n   */\n  cumulative?: boolean\n  Icon?: (index: number) => React.ComponentType\n}\n\ntype RatingRowProps = Omit<RatingProps, 'showScaleLabels' | 'leftHint' | 'rightHint'>\n\nconst RatingRow = ({\n  rangeCardinality,\n  disabled,\n  name,\n  onChange,\n  value,\n  cumulative,\n  defaultValue,\n  Icon,\n  ref,\n}: RatingRowProps) => {\n  // When `cumulative` is set, but not as a controlled component,\n  // we need to keep track of the current selected value from the rendered\n  // radios so that we can override the styles appropiately.\n  const [valueCC, setValueCC] = useState(value !== undefined ? value : defaultValue)\n  const styledAs = useMemo<(k: number) => undefined | RadioStyleState>(() => {\n    if (!cumulative) return () => undefined\n    if (!valueCC) return () => undefined\n    if (value !== undefined) return (k) => (k < value ? 'checked' : undefined)\n    return (k) => (k < valueCC ? 'checked' : undefined)\n  }, [cumulative, value, valueCC])\n\n  const valueProps = (k: number) =>\n    value !== undefined\n      ? {\n          checked: value === k,\n        }\n      : {}\n  return (\n    <FlexBox>\n      {[...new Array(rangeCardinality)].map((_v, k) => (\n        <Radio\n          ref={ref}\n          Icon={Icon && Icon(k)}\n          disabled={disabled}\n          name={name}\n          key={k}\n          {...(defaultValue === k\n            ? {\n                defaultChecked: true,\n              }\n            : {})}\n          css={css`\n            ${scaleSpacingCss}\n            margin-bottom: 0.5rem;\n            ${k === rangeCardinality - 1 ? `margin-right: 0;` : ''}\n          `}\n          onChange={(event) => {\n            if (event.target.checked) {\n              setValueCC(k)\n            }\n            onChange && onChange(k, event)\n          }}\n          styledAs={styledAs(k)}\n          value={k.toString()}\n          {...valueProps(k)}\n        />\n      ))}\n    </FlexBox>\n  )\n}\n\nexport const Rating = ({\n  rangeCardinality,\n  name,\n  leadingHint,\n  trailingHint,\n  scaleLabels,\n  onChange,\n  value,\n  disabled,\n  showScaleLabels = true,\n  cumulative,\n  defaultValue,\n  Icon,\n  ref,\n}: RatingProps) => {\n  const defaultLabels = [...new Array(rangeCardinality)].map((_v, k) => (k + 1).toString())\n  const labels = (scaleLabels && defaultLabels.map((_v, k) => scaleLabels(k))) || defaultLabels\n\n  const ratingProps = {\n    rangeCardinality,\n    name,\n    disabled,\n    onChange,\n    value,\n    cumulative,\n    defaultValue,\n    Icon,\n    ref,\n  }\n  return (\n    <FlexBox\n      {...(!showScaleLabels\n        ? {\n            css: css`\n              margin-top: 0.5rem;\n            `,\n          }\n        : {})}\n      itemsFlexEnd\n    >\n      {leadingHint && <RatingHint side=\"leading\">{leadingHint}</RatingHint>}\n      {showScaleLabels ? (\n        <span>\n          <FlexBox>\n            {labels.map((l, k) => (\n              <Text\n                key={l}\n                as=\"span\"\n                styledAs=\"bodyInterface\"\n                css={css`\n                  ${scaleSpacingCss}\n                  ${k === labels.length - 1 && `margin-right: 0;`}\n                  ${scaleLabelsSpacingCss}\n                  text-align: center;\n                  color: ${theme.colors.text.dark.secondary};\n                `}\n              >\n                {l}\n              </Text>\n            ))}\n          </FlexBox>\n          <RatingRow {...ratingProps} />\n        </span>\n      ) : (\n        <RatingRow {...ratingProps} />\n      )}\n      {trailingHint && <RatingHint side=\"trailing\">{trailingHint}</RatingHint>}\n    </FlexBox>\n  )\n}\n\nexport type RatingFieldProps = RatingProps &\n  Omit<FieldWrapProps, 'size' | 'placeholder' | 'helpPlacement' | 'children'> & {\n    size: Exclude<Size, 'large'>\n  }\n\n/**\n * The `RatingField` component will allow the user to provide feedback by ranking things on a specified scale.\n */\nexport const RatingField = ({\n  name,\n  label,\n  size,\n  errorMessage,\n  assistiveText,\n  hideAsterisk,\n  required,\n  rangeCardinality,\n  scaleLabels,\n  leadingHint,\n  trailingHint,\n  extraAssistiveText,\n  cumulative,\n  value,\n  help,\n  disabled,\n  onChange,\n  showScaleLabels,\n  defaultValue,\n  Icon,\n  className,\n  ref,\n}: RatingFieldProps) => {\n  return (\n    <FieldWrap\n      name={name}\n      label={label}\n      size={size}\n      errorMessage={errorMessage}\n      assistiveText={assistiveText}\n      extraAssistiveText={extraAssistiveText}\n      required={required}\n      help={help}\n      hideAsterisk={hideAsterisk}\n      disabled={disabled}\n      className={className}\n    >\n      <Rating\n        rangeCardinality={rangeCardinality}\n        scaleLabels={scaleLabels}\n        name={name}\n        leadingHint={leadingHint}\n        trailingHint={trailingHint}\n        value={value}\n        onChange={onChange}\n        disabled={disabled}\n        showScaleLabels={showScaleLabels}\n        cumulative={cumulative}\n        defaultValue={defaultValue}\n        Icon={Icon}\n        ref={ref}\n      />\n    </FieldWrap>\n  )\n}\n\nexport default RatingField\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+const scaleLabelsSpacingCss = process.env.NODE_ENV === "production" ? {
+  name: "lib5u1",
+  styles: "margin-bottom:0.5rem;padding-top:0.5rem"
+} : {
+  name: "koxgoq-scaleLabelsSpacingCss",
+  styles: "margin-bottom:0.5rem;padding-top:0.5rem;label:scaleLabelsSpacingCss;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/rating/Rating.tsx"],"names":[],"mappings":"AAgBiC","file":"../../../src/rating/Rating.tsx","sourcesContent":["import React, { ReactNode, useMemo, useState } from 'react'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\nimport { css } from '@emotion/react'\nimport { Radio, RadioStyleState } from '../radio'\nimport { Text } from '@dfds-ui/typography'\nimport { FieldWrap, FieldWrapProps } from '../field-wrap/FieldWrap'\nimport { theme } from '@dfds-ui/theme'\nimport { Size } from '../types'\n\nconst scaleSpacingCss = css`\n  width: 1.5rem;\n  margin-right: 1rem;\n  margin-left: 0;\n  margin-top: 0;\n`\n\nconst scaleLabelsSpacingCss = css`\n  margin-bottom: 0.5rem;\n  padding-top: 0.5rem;\n`\n\nconst RatingHint = ({ children, side }: { children: ReactNode; side: 'leading' | 'trailing' }) => {\n  return (\n    <Text\n      as=\"span\"\n      styledAs=\"bodyInterface\"\n      css={css`\n        padding-bottom: 0.5rem;\n        color: ${theme.colors.text.dark.secondary};\n        ${side === 'leading' ? `margin-right: 1rem;` : 'margin-left: 1rem;'}\n      `}\n    >\n      {children}\n    </Text>\n  )\n}\n\nexport type RatingProps = {\n  ref?: React.Ref<HTMLInputElement>\n  /**\n   * Amount of related checkboxes\n   */\n  rangeCardinality: number\n  /**\n   * Name for the checkbox group\n   */\n  name: string\n  /**\n   * Hint text on the left\n   */\n  leadingHint?: string\n  /**\n   * Hint text on the right\n   */\n  trailingHint?: string\n  /**\n   * Labels on top of the radio selectors, a string returning function called with the selector's index\n   */\n  scaleLabels?: (index: number) => string\n  /**\n   * If used as a controlled component, this value sets the selected radio\n   */\n  value?: number\n  /**\n   * Initial selected value\n   */\n  defaultValue?: number\n  /**\n   * Callback when the user changes the selected value\n   */\n  onChange?: (index: number, event: React.ChangeEvent<HTMLInputElement>) => void\n  disabled?: boolean\n  showScaleLabels?: boolean\n  /**\n   * When this property is `true`, it styles the radios to the left of the selected as `checked`\n   */\n  cumulative?: boolean\n  Icon?: (index: number) => React.ComponentType\n}\n\ntype RatingRowProps = Omit<RatingProps, 'showScaleLabels' | 'leftHint' | 'rightHint'>\n\nconst RatingRow = ({\n  rangeCardinality,\n  disabled,\n  name,\n  onChange,\n  value,\n  cumulative,\n  defaultValue,\n  Icon,\n  ref,\n}: RatingRowProps) => {\n  // When `cumulative` is set, but not as a controlled component,\n  // we need to keep track of the current selected value from the rendered\n  // radios so that we can override the styles appropiately.\n  const [valueCC, setValueCC] = useState(value !== undefined ? value : defaultValue)\n  const styledAs = useMemo<(k: number) => undefined | RadioStyleState>(() => {\n    if (!cumulative) return () => undefined\n    if (!valueCC) return () => undefined\n    if (value !== undefined) return (k) => (k < value ? 'checked' : undefined)\n    return (k) => (k < valueCC ? 'checked' : undefined)\n  }, [cumulative, value, valueCC])\n\n  const valueProps = (k: number) =>\n    value !== undefined\n      ? {\n          checked: value === k,\n        }\n      : {}\n  return (\n    <FlexBox>\n      {[...new Array(rangeCardinality)].map((_v, k) => (\n        <Radio\n          ref={ref}\n          Icon={Icon && Icon(k)}\n          disabled={disabled}\n          name={name}\n          key={k}\n          {...(defaultValue === k\n            ? {\n                defaultChecked: true,\n              }\n            : {})}\n          css={css`\n            ${scaleSpacingCss}\n            margin-bottom: 0.5rem;\n            ${k === rangeCardinality - 1 ? `margin-right: 0;` : ''}\n          `}\n          onChange={(event) => {\n            if (event.target.checked) {\n              setValueCC(k)\n            }\n            onChange && onChange(k, event)\n          }}\n          styledAs={styledAs(k)}\n          value={k.toString()}\n          {...valueProps(k)}\n        />\n      ))}\n    </FlexBox>\n  )\n}\n\nexport const Rating = ({\n  rangeCardinality,\n  name,\n  leadingHint,\n  trailingHint,\n  scaleLabels,\n  onChange,\n  value,\n  disabled,\n  showScaleLabels = true,\n  cumulative,\n  defaultValue,\n  Icon,\n  ref,\n}: RatingProps) => {\n  const defaultLabels = [...new Array(rangeCardinality)].map((_v, k) => (k + 1).toString())\n  const labels = (scaleLabels && defaultLabels.map((_v, k) => scaleLabels(k))) || defaultLabels\n\n  const ratingProps = {\n    rangeCardinality,\n    name,\n    disabled,\n    onChange,\n    value,\n    cumulative,\n    defaultValue,\n    Icon,\n    ref,\n  }\n  return (\n    <FlexBox\n      {...(!showScaleLabels\n        ? {\n            css: css`\n              margin-top: 0.5rem;\n            `,\n          }\n        : {})}\n      itemsFlexEnd\n    >\n      {leadingHint && <RatingHint side=\"leading\">{leadingHint}</RatingHint>}\n      {showScaleLabels ? (\n        <span>\n          <FlexBox>\n            {labels.map((l, k) => (\n              <Text\n                key={l}\n                as=\"span\"\n                styledAs=\"bodyInterface\"\n                css={css`\n                  ${scaleSpacingCss}\n                  ${k === labels.length - 1 && `margin-right: 0;`}\n                  ${scaleLabelsSpacingCss}\n                  text-align: center;\n                  color: ${theme.colors.text.dark.secondary};\n                `}\n              >\n                {l}\n              </Text>\n            ))}\n          </FlexBox>\n          <RatingRow {...ratingProps} />\n        </span>\n      ) : (\n        <RatingRow {...ratingProps} />\n      )}\n      {trailingHint && <RatingHint side=\"trailing\">{trailingHint}</RatingHint>}\n    </FlexBox>\n  )\n}\n\nexport type RatingFieldProps = RatingProps &\n  Omit<FieldWrapProps, 'size' | 'placeholder' | 'helpPlacement' | 'children'> & {\n    size: Exclude<Size, 'large'>\n  }\n\n/**\n * The `RatingField` component will allow the user to provide feedback by ranking things on a specified scale.\n */\nexport const RatingField = ({\n  name,\n  label,\n  size,\n  errorMessage,\n  assistiveText,\n  hideAsterisk,\n  required,\n  rangeCardinality,\n  scaleLabels,\n  leadingHint,\n  trailingHint,\n  extraAssistiveText,\n  cumulative,\n  value,\n  help,\n  disabled,\n  onChange,\n  showScaleLabels,\n  defaultValue,\n  Icon,\n  className,\n  ref,\n}: RatingFieldProps) => {\n  return (\n    <FieldWrap\n      name={name}\n      label={label}\n      size={size}\n      errorMessage={errorMessage}\n      assistiveText={assistiveText}\n      extraAssistiveText={extraAssistiveText}\n      required={required}\n      help={help}\n      hideAsterisk={hideAsterisk}\n      disabled={disabled}\n      className={className}\n    >\n      <Rating\n        rangeCardinality={rangeCardinality}\n        scaleLabels={scaleLabels}\n        name={name}\n        leadingHint={leadingHint}\n        trailingHint={trailingHint}\n        value={value}\n        onChange={onChange}\n        disabled={disabled}\n        showScaleLabels={showScaleLabels}\n        cumulative={cumulative}\n        defaultValue={defaultValue}\n        Icon={Icon}\n        ref={ref}\n      />\n    </FieldWrap>\n  )\n}\n\nexport default RatingField\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+const RatingHint = ({
+  children,
+  side
+}) => {
+  return (0, _jsxRuntime.jsx)(_typography.Text, {
+    as: "span",
+    styledAs: "bodyInterface",
+    css: /*#__PURE__*/(0, _react2.css)("padding-bottom:0.5rem;color:", _theme.theme.colors.text.dark.secondary, ";", side === 'leading' ? `margin-right: 1rem;` : 'margin-left: 1rem;', ";" + (process.env.NODE_ENV === "production" ? "" : ";label:RatingHint;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/rating/Rating.tsx"],"names":[],"mappings":"AA0Bc","file":"../../../src/rating/Rating.tsx","sourcesContent":["import React, { ReactNode, useMemo, useState } from 'react'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\nimport { css } from '@emotion/react'\nimport { Radio, RadioStyleState } from '../radio'\nimport { Text } from '@dfds-ui/typography'\nimport { FieldWrap, FieldWrapProps } from '../field-wrap/FieldWrap'\nimport { theme } from '@dfds-ui/theme'\nimport { Size } from '../types'\n\nconst scaleSpacingCss = css`\n  width: 1.5rem;\n  margin-right: 1rem;\n  margin-left: 0;\n  margin-top: 0;\n`\n\nconst scaleLabelsSpacingCss = css`\n  margin-bottom: 0.5rem;\n  padding-top: 0.5rem;\n`\n\nconst RatingHint = ({ children, side }: { children: ReactNode; side: 'leading' | 'trailing' }) => {\n  return (\n    <Text\n      as=\"span\"\n      styledAs=\"bodyInterface\"\n      css={css`\n        padding-bottom: 0.5rem;\n        color: ${theme.colors.text.dark.secondary};\n        ${side === 'leading' ? `margin-right: 1rem;` : 'margin-left: 1rem;'}\n      `}\n    >\n      {children}\n    </Text>\n  )\n}\n\nexport type RatingProps = {\n  ref?: React.Ref<HTMLInputElement>\n  /**\n   * Amount of related checkboxes\n   */\n  rangeCardinality: number\n  /**\n   * Name for the checkbox group\n   */\n  name: string\n  /**\n   * Hint text on the left\n   */\n  leadingHint?: string\n  /**\n   * Hint text on the right\n   */\n  trailingHint?: string\n  /**\n   * Labels on top of the radio selectors, a string returning function called with the selector's index\n   */\n  scaleLabels?: (index: number) => string\n  /**\n   * If used as a controlled component, this value sets the selected radio\n   */\n  value?: number\n  /**\n   * Initial selected value\n   */\n  defaultValue?: number\n  /**\n   * Callback when the user changes the selected value\n   */\n  onChange?: (index: number, event: React.ChangeEvent<HTMLInputElement>) => void\n  disabled?: boolean\n  showScaleLabels?: boolean\n  /**\n   * When this property is `true`, it styles the radios to the left of the selected as `checked`\n   */\n  cumulative?: boolean\n  Icon?: (index: number) => React.ComponentType\n}\n\ntype RatingRowProps = Omit<RatingProps, 'showScaleLabels' | 'leftHint' | 'rightHint'>\n\nconst RatingRow = ({\n  rangeCardinality,\n  disabled,\n  name,\n  onChange,\n  value,\n  cumulative,\n  defaultValue,\n  Icon,\n  ref,\n}: RatingRowProps) => {\n  // When `cumulative` is set, but not as a controlled component,\n  // we need to keep track of the current selected value from the rendered\n  // radios so that we can override the styles appropiately.\n  const [valueCC, setValueCC] = useState(value !== undefined ? value : defaultValue)\n  const styledAs = useMemo<(k: number) => undefined | RadioStyleState>(() => {\n    if (!cumulative) return () => undefined\n    if (!valueCC) return () => undefined\n    if (value !== undefined) return (k) => (k < value ? 'checked' : undefined)\n    return (k) => (k < valueCC ? 'checked' : undefined)\n  }, [cumulative, value, valueCC])\n\n  const valueProps = (k: number) =>\n    value !== undefined\n      ? {\n          checked: value === k,\n        }\n      : {}\n  return (\n    <FlexBox>\n      {[...new Array(rangeCardinality)].map((_v, k) => (\n        <Radio\n          ref={ref}\n          Icon={Icon && Icon(k)}\n          disabled={disabled}\n          name={name}\n          key={k}\n          {...(defaultValue === k\n            ? {\n                defaultChecked: true,\n              }\n            : {})}\n          css={css`\n            ${scaleSpacingCss}\n            margin-bottom: 0.5rem;\n            ${k === rangeCardinality - 1 ? `margin-right: 0;` : ''}\n          `}\n          onChange={(event) => {\n            if (event.target.checked) {\n              setValueCC(k)\n            }\n            onChange && onChange(k, event)\n          }}\n          styledAs={styledAs(k)}\n          value={k.toString()}\n          {...valueProps(k)}\n        />\n      ))}\n    </FlexBox>\n  )\n}\n\nexport const Rating = ({\n  rangeCardinality,\n  name,\n  leadingHint,\n  trailingHint,\n  scaleLabels,\n  onChange,\n  value,\n  disabled,\n  showScaleLabels = true,\n  cumulative,\n  defaultValue,\n  Icon,\n  ref,\n}: RatingProps) => {\n  const defaultLabels = [...new Array(rangeCardinality)].map((_v, k) => (k + 1).toString())\n  const labels = (scaleLabels && defaultLabels.map((_v, k) => scaleLabels(k))) || defaultLabels\n\n  const ratingProps = {\n    rangeCardinality,\n    name,\n    disabled,\n    onChange,\n    value,\n    cumulative,\n    defaultValue,\n    Icon,\n    ref,\n  }\n  return (\n    <FlexBox\n      {...(!showScaleLabels\n        ? {\n            css: css`\n              margin-top: 0.5rem;\n            `,\n          }\n        : {})}\n      itemsFlexEnd\n    >\n      {leadingHint && <RatingHint side=\"leading\">{leadingHint}</RatingHint>}\n      {showScaleLabels ? (\n        <span>\n          <FlexBox>\n            {labels.map((l, k) => (\n              <Text\n                key={l}\n                as=\"span\"\n                styledAs=\"bodyInterface\"\n                css={css`\n                  ${scaleSpacingCss}\n                  ${k === labels.length - 1 && `margin-right: 0;`}\n                  ${scaleLabelsSpacingCss}\n                  text-align: center;\n                  color: ${theme.colors.text.dark.secondary};\n                `}\n              >\n                {l}\n              </Text>\n            ))}\n          </FlexBox>\n          <RatingRow {...ratingProps} />\n        </span>\n      ) : (\n        <RatingRow {...ratingProps} />\n      )}\n      {trailingHint && <RatingHint side=\"trailing\">{trailingHint}</RatingHint>}\n    </FlexBox>\n  )\n}\n\nexport type RatingFieldProps = RatingProps &\n  Omit<FieldWrapProps, 'size' | 'placeholder' | 'helpPlacement' | 'children'> & {\n    size: Exclude<Size, 'large'>\n  }\n\n/**\n * The `RatingField` component will allow the user to provide feedback by ranking things on a specified scale.\n */\nexport const RatingField = ({\n  name,\n  label,\n  size,\n  errorMessage,\n  assistiveText,\n  hideAsterisk,\n  required,\n  rangeCardinality,\n  scaleLabels,\n  leadingHint,\n  trailingHint,\n  extraAssistiveText,\n  cumulative,\n  value,\n  help,\n  disabled,\n  onChange,\n  showScaleLabels,\n  defaultValue,\n  Icon,\n  className,\n  ref,\n}: RatingFieldProps) => {\n  return (\n    <FieldWrap\n      name={name}\n      label={label}\n      size={size}\n      errorMessage={errorMessage}\n      assistiveText={assistiveText}\n      extraAssistiveText={extraAssistiveText}\n      required={required}\n      help={help}\n      hideAsterisk={hideAsterisk}\n      disabled={disabled}\n      className={className}\n    >\n      <Rating\n        rangeCardinality={rangeCardinality}\n        scaleLabels={scaleLabels}\n        name={name}\n        leadingHint={leadingHint}\n        trailingHint={trailingHint}\n        value={value}\n        onChange={onChange}\n        disabled={disabled}\n        showScaleLabels={showScaleLabels}\n        cumulative={cumulative}\n        defaultValue={defaultValue}\n        Icon={Icon}\n        ref={ref}\n      />\n    </FieldWrap>\n  )\n}\n\nexport default RatingField\n"]} */"),
+    children: children
+  });
+};
+const RatingRow = ({
+  rangeCardinality,
+  disabled,
+  name,
+  onChange,
+  value,
+  cumulative,
+  defaultValue,
+  Icon,
+  ref
+}) => {
+  // When `cumulative` is set, but not as a controlled component,
+  // we need to keep track of the current selected value from the rendered
+  // radios so that we can override the styles appropiately.
+  const [valueCC, setValueCC] = (0, _react.useState)(value !== undefined ? value : defaultValue);
+  const styledAs = (0, _react.useMemo)(() => {
+    if (!cumulative) return () => undefined;
+    if (!valueCC) return () => undefined;
+    if (value !== undefined) return k => k < value ? 'checked' : undefined;
+    return k => k < valueCC ? 'checked' : undefined;
+  }, [cumulative, value, valueCC]);
+  const valueProps = k => value !== undefined ? {
+    checked: value === k
+  } : {};
+  return (0, _jsxRuntime.jsx)(_flexbox.FlexBox, {
+    children: [...new Array(rangeCardinality)].map((_v, k) => (0, _jsxRuntime.jsx)(_radio.Radio, {
+      ref: ref,
+      Icon: Icon && Icon(k),
+      disabled: disabled,
+      name: name,
+      ...(defaultValue === k ? {
+        defaultChecked: true
+      } : {}),
+      css: /*#__PURE__*/(0, _react2.css)(scaleSpacingCss, " margin-bottom:0.5rem;", k === rangeCardinality - 1 ? `margin-right: 0;` : '', ";" + (process.env.NODE_ENV === "production" ? "" : ";label:RatingRow;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/rating/Rating.tsx"],"names":[],"mappings":"AA4HkB","file":"../../../src/rating/Rating.tsx","sourcesContent":["import React, { ReactNode, useMemo, useState } from 'react'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\nimport { css } from '@emotion/react'\nimport { Radio, RadioStyleState } from '../radio'\nimport { Text } from '@dfds-ui/typography'\nimport { FieldWrap, FieldWrapProps } from '../field-wrap/FieldWrap'\nimport { theme } from '@dfds-ui/theme'\nimport { Size } from '../types'\n\nconst scaleSpacingCss = css`\n  width: 1.5rem;\n  margin-right: 1rem;\n  margin-left: 0;\n  margin-top: 0;\n`\n\nconst scaleLabelsSpacingCss = css`\n  margin-bottom: 0.5rem;\n  padding-top: 0.5rem;\n`\n\nconst RatingHint = ({ children, side }: { children: ReactNode; side: 'leading' | 'trailing' }) => {\n  return (\n    <Text\n      as=\"span\"\n      styledAs=\"bodyInterface\"\n      css={css`\n        padding-bottom: 0.5rem;\n        color: ${theme.colors.text.dark.secondary};\n        ${side === 'leading' ? `margin-right: 1rem;` : 'margin-left: 1rem;'}\n      `}\n    >\n      {children}\n    </Text>\n  )\n}\n\nexport type RatingProps = {\n  ref?: React.Ref<HTMLInputElement>\n  /**\n   * Amount of related checkboxes\n   */\n  rangeCardinality: number\n  /**\n   * Name for the checkbox group\n   */\n  name: string\n  /**\n   * Hint text on the left\n   */\n  leadingHint?: string\n  /**\n   * Hint text on the right\n   */\n  trailingHint?: string\n  /**\n   * Labels on top of the radio selectors, a string returning function called with the selector's index\n   */\n  scaleLabels?: (index: number) => string\n  /**\n   * If used as a controlled component, this value sets the selected radio\n   */\n  value?: number\n  /**\n   * Initial selected value\n   */\n  defaultValue?: number\n  /**\n   * Callback when the user changes the selected value\n   */\n  onChange?: (index: number, event: React.ChangeEvent<HTMLInputElement>) => void\n  disabled?: boolean\n  showScaleLabels?: boolean\n  /**\n   * When this property is `true`, it styles the radios to the left of the selected as `checked`\n   */\n  cumulative?: boolean\n  Icon?: (index: number) => React.ComponentType\n}\n\ntype RatingRowProps = Omit<RatingProps, 'showScaleLabels' | 'leftHint' | 'rightHint'>\n\nconst RatingRow = ({\n  rangeCardinality,\n  disabled,\n  name,\n  onChange,\n  value,\n  cumulative,\n  defaultValue,\n  Icon,\n  ref,\n}: RatingRowProps) => {\n  // When `cumulative` is set, but not as a controlled component,\n  // we need to keep track of the current selected value from the rendered\n  // radios so that we can override the styles appropiately.\n  const [valueCC, setValueCC] = useState(value !== undefined ? value : defaultValue)\n  const styledAs = useMemo<(k: number) => undefined | RadioStyleState>(() => {\n    if (!cumulative) return () => undefined\n    if (!valueCC) return () => undefined\n    if (value !== undefined) return (k) => (k < value ? 'checked' : undefined)\n    return (k) => (k < valueCC ? 'checked' : undefined)\n  }, [cumulative, value, valueCC])\n\n  const valueProps = (k: number) =>\n    value !== undefined\n      ? {\n          checked: value === k,\n        }\n      : {}\n  return (\n    <FlexBox>\n      {[...new Array(rangeCardinality)].map((_v, k) => (\n        <Radio\n          ref={ref}\n          Icon={Icon && Icon(k)}\n          disabled={disabled}\n          name={name}\n          key={k}\n          {...(defaultValue === k\n            ? {\n                defaultChecked: true,\n              }\n            : {})}\n          css={css`\n            ${scaleSpacingCss}\n            margin-bottom: 0.5rem;\n            ${k === rangeCardinality - 1 ? `margin-right: 0;` : ''}\n          `}\n          onChange={(event) => {\n            if (event.target.checked) {\n              setValueCC(k)\n            }\n            onChange && onChange(k, event)\n          }}\n          styledAs={styledAs(k)}\n          value={k.toString()}\n          {...valueProps(k)}\n        />\n      ))}\n    </FlexBox>\n  )\n}\n\nexport const Rating = ({\n  rangeCardinality,\n  name,\n  leadingHint,\n  trailingHint,\n  scaleLabels,\n  onChange,\n  value,\n  disabled,\n  showScaleLabels = true,\n  cumulative,\n  defaultValue,\n  Icon,\n  ref,\n}: RatingProps) => {\n  const defaultLabels = [...new Array(rangeCardinality)].map((_v, k) => (k + 1).toString())\n  const labels = (scaleLabels && defaultLabels.map((_v, k) => scaleLabels(k))) || defaultLabels\n\n  const ratingProps = {\n    rangeCardinality,\n    name,\n    disabled,\n    onChange,\n    value,\n    cumulative,\n    defaultValue,\n    Icon,\n    ref,\n  }\n  return (\n    <FlexBox\n      {...(!showScaleLabels\n        ? {\n            css: css`\n              margin-top: 0.5rem;\n            `,\n          }\n        : {})}\n      itemsFlexEnd\n    >\n      {leadingHint && <RatingHint side=\"leading\">{leadingHint}</RatingHint>}\n      {showScaleLabels ? (\n        <span>\n          <FlexBox>\n            {labels.map((l, k) => (\n              <Text\n                key={l}\n                as=\"span\"\n                styledAs=\"bodyInterface\"\n                css={css`\n                  ${scaleSpacingCss}\n                  ${k === labels.length - 1 && `margin-right: 0;`}\n                  ${scaleLabelsSpacingCss}\n                  text-align: center;\n                  color: ${theme.colors.text.dark.secondary};\n                `}\n              >\n                {l}\n              </Text>\n            ))}\n          </FlexBox>\n          <RatingRow {...ratingProps} />\n        </span>\n      ) : (\n        <RatingRow {...ratingProps} />\n      )}\n      {trailingHint && <RatingHint side=\"trailing\">{trailingHint}</RatingHint>}\n    </FlexBox>\n  )\n}\n\nexport type RatingFieldProps = RatingProps &\n  Omit<FieldWrapProps, 'size' | 'placeholder' | 'helpPlacement' | 'children'> & {\n    size: Exclude<Size, 'large'>\n  }\n\n/**\n * The `RatingField` component will allow the user to provide feedback by ranking things on a specified scale.\n */\nexport const RatingField = ({\n  name,\n  label,\n  size,\n  errorMessage,\n  assistiveText,\n  hideAsterisk,\n  required,\n  rangeCardinality,\n  scaleLabels,\n  leadingHint,\n  trailingHint,\n  extraAssistiveText,\n  cumulative,\n  value,\n  help,\n  disabled,\n  onChange,\n  showScaleLabels,\n  defaultValue,\n  Icon,\n  className,\n  ref,\n}: RatingFieldProps) => {\n  return (\n    <FieldWrap\n      name={name}\n      label={label}\n      size={size}\n      errorMessage={errorMessage}\n      assistiveText={assistiveText}\n      extraAssistiveText={extraAssistiveText}\n      required={required}\n      help={help}\n      hideAsterisk={hideAsterisk}\n      disabled={disabled}\n      className={className}\n    >\n      <Rating\n        rangeCardinality={rangeCardinality}\n        scaleLabels={scaleLabels}\n        name={name}\n        leadingHint={leadingHint}\n        trailingHint={trailingHint}\n        value={value}\n        onChange={onChange}\n        disabled={disabled}\n        showScaleLabels={showScaleLabels}\n        cumulative={cumulative}\n        defaultValue={defaultValue}\n        Icon={Icon}\n        ref={ref}\n      />\n    </FieldWrap>\n  )\n}\n\nexport default RatingField\n"]} */"),
+      onChange: event => {
+        if (event.target.checked) {
+          setValueCC(k);
+        }
+        onChange && onChange(k, event);
+      },
+      styledAs: styledAs(k),
+      value: k.toString(),
+      ...valueProps(k)
+    }, k))
+  });
+};
+var _ref = process.env.NODE_ENV === "production" ? {
+  name: "1e4sizb",
+  styles: "margin-top:0.5rem"
+} : {
+  name: "1mcgxdt-css",
+  styles: "margin-top:0.5rem;label:css;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/rating/Rating.tsx"],"names":[],"mappings":"AAiLoB","file":"../../../src/rating/Rating.tsx","sourcesContent":["import React, { ReactNode, useMemo, useState } from 'react'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\nimport { css } from '@emotion/react'\nimport { Radio, RadioStyleState } from '../radio'\nimport { Text } from '@dfds-ui/typography'\nimport { FieldWrap, FieldWrapProps } from '../field-wrap/FieldWrap'\nimport { theme } from '@dfds-ui/theme'\nimport { Size } from '../types'\n\nconst scaleSpacingCss = css`\n  width: 1.5rem;\n  margin-right: 1rem;\n  margin-left: 0;\n  margin-top: 0;\n`\n\nconst scaleLabelsSpacingCss = css`\n  margin-bottom: 0.5rem;\n  padding-top: 0.5rem;\n`\n\nconst RatingHint = ({ children, side }: { children: ReactNode; side: 'leading' | 'trailing' }) => {\n  return (\n    <Text\n      as=\"span\"\n      styledAs=\"bodyInterface\"\n      css={css`\n        padding-bottom: 0.5rem;\n        color: ${theme.colors.text.dark.secondary};\n        ${side === 'leading' ? `margin-right: 1rem;` : 'margin-left: 1rem;'}\n      `}\n    >\n      {children}\n    </Text>\n  )\n}\n\nexport type RatingProps = {\n  ref?: React.Ref<HTMLInputElement>\n  /**\n   * Amount of related checkboxes\n   */\n  rangeCardinality: number\n  /**\n   * Name for the checkbox group\n   */\n  name: string\n  /**\n   * Hint text on the left\n   */\n  leadingHint?: string\n  /**\n   * Hint text on the right\n   */\n  trailingHint?: string\n  /**\n   * Labels on top of the radio selectors, a string returning function called with the selector's index\n   */\n  scaleLabels?: (index: number) => string\n  /**\n   * If used as a controlled component, this value sets the selected radio\n   */\n  value?: number\n  /**\n   * Initial selected value\n   */\n  defaultValue?: number\n  /**\n   * Callback when the user changes the selected value\n   */\n  onChange?: (index: number, event: React.ChangeEvent<HTMLInputElement>) => void\n  disabled?: boolean\n  showScaleLabels?: boolean\n  /**\n   * When this property is `true`, it styles the radios to the left of the selected as `checked`\n   */\n  cumulative?: boolean\n  Icon?: (index: number) => React.ComponentType\n}\n\ntype RatingRowProps = Omit<RatingProps, 'showScaleLabels' | 'leftHint' | 'rightHint'>\n\nconst RatingRow = ({\n  rangeCardinality,\n  disabled,\n  name,\n  onChange,\n  value,\n  cumulative,\n  defaultValue,\n  Icon,\n  ref,\n}: RatingRowProps) => {\n  // When `cumulative` is set, but not as a controlled component,\n  // we need to keep track of the current selected value from the rendered\n  // radios so that we can override the styles appropiately.\n  const [valueCC, setValueCC] = useState(value !== undefined ? value : defaultValue)\n  const styledAs = useMemo<(k: number) => undefined | RadioStyleState>(() => {\n    if (!cumulative) return () => undefined\n    if (!valueCC) return () => undefined\n    if (value !== undefined) return (k) => (k < value ? 'checked' : undefined)\n    return (k) => (k < valueCC ? 'checked' : undefined)\n  }, [cumulative, value, valueCC])\n\n  const valueProps = (k: number) =>\n    value !== undefined\n      ? {\n          checked: value === k,\n        }\n      : {}\n  return (\n    <FlexBox>\n      {[...new Array(rangeCardinality)].map((_v, k) => (\n        <Radio\n          ref={ref}\n          Icon={Icon && Icon(k)}\n          disabled={disabled}\n          name={name}\n          key={k}\n          {...(defaultValue === k\n            ? {\n                defaultChecked: true,\n              }\n            : {})}\n          css={css`\n            ${scaleSpacingCss}\n            margin-bottom: 0.5rem;\n            ${k === rangeCardinality - 1 ? `margin-right: 0;` : ''}\n          `}\n          onChange={(event) => {\n            if (event.target.checked) {\n              setValueCC(k)\n            }\n            onChange && onChange(k, event)\n          }}\n          styledAs={styledAs(k)}\n          value={k.toString()}\n          {...valueProps(k)}\n        />\n      ))}\n    </FlexBox>\n  )\n}\n\nexport const Rating = ({\n  rangeCardinality,\n  name,\n  leadingHint,\n  trailingHint,\n  scaleLabels,\n  onChange,\n  value,\n  disabled,\n  showScaleLabels = true,\n  cumulative,\n  defaultValue,\n  Icon,\n  ref,\n}: RatingProps) => {\n  const defaultLabels = [...new Array(rangeCardinality)].map((_v, k) => (k + 1).toString())\n  const labels = (scaleLabels && defaultLabels.map((_v, k) => scaleLabels(k))) || defaultLabels\n\n  const ratingProps = {\n    rangeCardinality,\n    name,\n    disabled,\n    onChange,\n    value,\n    cumulative,\n    defaultValue,\n    Icon,\n    ref,\n  }\n  return (\n    <FlexBox\n      {...(!showScaleLabels\n        ? {\n            css: css`\n              margin-top: 0.5rem;\n            `,\n          }\n        : {})}\n      itemsFlexEnd\n    >\n      {leadingHint && <RatingHint side=\"leading\">{leadingHint}</RatingHint>}\n      {showScaleLabels ? (\n        <span>\n          <FlexBox>\n            {labels.map((l, k) => (\n              <Text\n                key={l}\n                as=\"span\"\n                styledAs=\"bodyInterface\"\n                css={css`\n                  ${scaleSpacingCss}\n                  ${k === labels.length - 1 && `margin-right: 0;`}\n                  ${scaleLabelsSpacingCss}\n                  text-align: center;\n                  color: ${theme.colors.text.dark.secondary};\n                `}\n              >\n                {l}\n              </Text>\n            ))}\n          </FlexBox>\n          <RatingRow {...ratingProps} />\n        </span>\n      ) : (\n        <RatingRow {...ratingProps} />\n      )}\n      {trailingHint && <RatingHint side=\"trailing\">{trailingHint}</RatingHint>}\n    </FlexBox>\n  )\n}\n\nexport type RatingFieldProps = RatingProps &\n  Omit<FieldWrapProps, 'size' | 'placeholder' | 'helpPlacement' | 'children'> & {\n    size: Exclude<Size, 'large'>\n  }\n\n/**\n * The `RatingField` component will allow the user to provide feedback by ranking things on a specified scale.\n */\nexport const RatingField = ({\n  name,\n  label,\n  size,\n  errorMessage,\n  assistiveText,\n  hideAsterisk,\n  required,\n  rangeCardinality,\n  scaleLabels,\n  leadingHint,\n  trailingHint,\n  extraAssistiveText,\n  cumulative,\n  value,\n  help,\n  disabled,\n  onChange,\n  showScaleLabels,\n  defaultValue,\n  Icon,\n  className,\n  ref,\n}: RatingFieldProps) => {\n  return (\n    <FieldWrap\n      name={name}\n      label={label}\n      size={size}\n      errorMessage={errorMessage}\n      assistiveText={assistiveText}\n      extraAssistiveText={extraAssistiveText}\n      required={required}\n      help={help}\n      hideAsterisk={hideAsterisk}\n      disabled={disabled}\n      className={className}\n    >\n      <Rating\n        rangeCardinality={rangeCardinality}\n        scaleLabels={scaleLabels}\n        name={name}\n        leadingHint={leadingHint}\n        trailingHint={trailingHint}\n        value={value}\n        onChange={onChange}\n        disabled={disabled}\n        showScaleLabels={showScaleLabels}\n        cumulative={cumulative}\n        defaultValue={defaultValue}\n        Icon={Icon}\n        ref={ref}\n      />\n    </FieldWrap>\n  )\n}\n\nexport default RatingField\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+const Rating = ({
+  rangeCardinality,
+  name,
+  leadingHint,
+  trailingHint,
+  scaleLabels,
+  onChange,
+  value,
+  disabled,
+  showScaleLabels = true,
+  cumulative,
+  defaultValue,
+  Icon,
+  ref
+}) => {
+  const defaultLabels = [...new Array(rangeCardinality)].map((_v, k) => (k + 1).toString());
+  const labels = scaleLabels && defaultLabels.map((_v, k) => scaleLabels(k)) || defaultLabels;
+  const ratingProps = {
+    rangeCardinality,
+    name,
+    disabled,
+    onChange,
+    value,
+    cumulative,
+    defaultValue,
+    Icon,
+    ref
+  };
+  return (0, _jsxRuntime.jsxs)(_flexbox.FlexBox, {
+    ...(!showScaleLabels ? {
+      css: _ref
+    } : {}),
+    itemsFlexEnd: true,
+    children: [leadingHint && (0, _jsxRuntime.jsx)(RatingHint, {
+      side: "leading",
+      children: leadingHint
+    }), showScaleLabels ? (0, _jsxRuntime.jsxs)("span", {
+      children: [(0, _jsxRuntime.jsx)(_flexbox.FlexBox, {
+        children: labels.map((l, k) => (0, _jsxRuntime.jsx)(_typography.Text, {
+          as: "span",
+          styledAs: "bodyInterface",
+          css: /*#__PURE__*/(0, _react2.css)(scaleSpacingCss, " ", k === labels.length - 1 && `margin-right: 0;`, " ", scaleLabelsSpacingCss, " text-align:center;color:", _theme.theme.colors.text.dark.secondary, ";" + (process.env.NODE_ENV === "production" ? "" : ";label:Rating;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/rating/Rating.tsx"],"names":[],"mappings":"AAiMwB","file":"../../../src/rating/Rating.tsx","sourcesContent":["import React, { ReactNode, useMemo, useState } from 'react'\nimport { FlexBox } from '@dfds-ui/react-components/flexbox'\nimport { css } from '@emotion/react'\nimport { Radio, RadioStyleState } from '../radio'\nimport { Text } from '@dfds-ui/typography'\nimport { FieldWrap, FieldWrapProps } from '../field-wrap/FieldWrap'\nimport { theme } from '@dfds-ui/theme'\nimport { Size } from '../types'\n\nconst scaleSpacingCss = css`\n  width: 1.5rem;\n  margin-right: 1rem;\n  margin-left: 0;\n  margin-top: 0;\n`\n\nconst scaleLabelsSpacingCss = css`\n  margin-bottom: 0.5rem;\n  padding-top: 0.5rem;\n`\n\nconst RatingHint = ({ children, side }: { children: ReactNode; side: 'leading' | 'trailing' }) => {\n  return (\n    <Text\n      as=\"span\"\n      styledAs=\"bodyInterface\"\n      css={css`\n        padding-bottom: 0.5rem;\n        color: ${theme.colors.text.dark.secondary};\n        ${side === 'leading' ? `margin-right: 1rem;` : 'margin-left: 1rem;'}\n      `}\n    >\n      {children}\n    </Text>\n  )\n}\n\nexport type RatingProps = {\n  ref?: React.Ref<HTMLInputElement>\n  /**\n   * Amount of related checkboxes\n   */\n  rangeCardinality: number\n  /**\n   * Name for the checkbox group\n   */\n  name: string\n  /**\n   * Hint text on the left\n   */\n  leadingHint?: string\n  /**\n   * Hint text on the right\n   */\n  trailingHint?: string\n  /**\n   * Labels on top of the radio selectors, a string returning function called with the selector's index\n   */\n  scaleLabels?: (index: number) => string\n  /**\n   * If used as a controlled component, this value sets the selected radio\n   */\n  value?: number\n  /**\n   * Initial selected value\n   */\n  defaultValue?: number\n  /**\n   * Callback when the user changes the selected value\n   */\n  onChange?: (index: number, event: React.ChangeEvent<HTMLInputElement>) => void\n  disabled?: boolean\n  showScaleLabels?: boolean\n  /**\n   * When this property is `true`, it styles the radios to the left of the selected as `checked`\n   */\n  cumulative?: boolean\n  Icon?: (index: number) => React.ComponentType\n}\n\ntype RatingRowProps = Omit<RatingProps, 'showScaleLabels' | 'leftHint' | 'rightHint'>\n\nconst RatingRow = ({\n  rangeCardinality,\n  disabled,\n  name,\n  onChange,\n  value,\n  cumulative,\n  defaultValue,\n  Icon,\n  ref,\n}: RatingRowProps) => {\n  // When `cumulative` is set, but not as a controlled component,\n  // we need to keep track of the current selected value from the rendered\n  // radios so that we can override the styles appropiately.\n  const [valueCC, setValueCC] = useState(value !== undefined ? value : defaultValue)\n  const styledAs = useMemo<(k: number) => undefined | RadioStyleState>(() => {\n    if (!cumulative) return () => undefined\n    if (!valueCC) return () => undefined\n    if (value !== undefined) return (k) => (k < value ? 'checked' : undefined)\n    return (k) => (k < valueCC ? 'checked' : undefined)\n  }, [cumulative, value, valueCC])\n\n  const valueProps = (k: number) =>\n    value !== undefined\n      ? {\n          checked: value === k,\n        }\n      : {}\n  return (\n    <FlexBox>\n      {[...new Array(rangeCardinality)].map((_v, k) => (\n        <Radio\n          ref={ref}\n          Icon={Icon && Icon(k)}\n          disabled={disabled}\n          name={name}\n          key={k}\n          {...(defaultValue === k\n            ? {\n                defaultChecked: true,\n              }\n            : {})}\n          css={css`\n            ${scaleSpacingCss}\n            margin-bottom: 0.5rem;\n            ${k === rangeCardinality - 1 ? `margin-right: 0;` : ''}\n          `}\n          onChange={(event) => {\n            if (event.target.checked) {\n              setValueCC(k)\n            }\n            onChange && onChange(k, event)\n          }}\n          styledAs={styledAs(k)}\n          value={k.toString()}\n          {...valueProps(k)}\n        />\n      ))}\n    </FlexBox>\n  )\n}\n\nexport const Rating = ({\n  rangeCardinality,\n  name,\n  leadingHint,\n  trailingHint,\n  scaleLabels,\n  onChange,\n  value,\n  disabled,\n  showScaleLabels = true,\n  cumulative,\n  defaultValue,\n  Icon,\n  ref,\n}: RatingProps) => {\n  const defaultLabels = [...new Array(rangeCardinality)].map((_v, k) => (k + 1).toString())\n  const labels = (scaleLabels && defaultLabels.map((_v, k) => scaleLabels(k))) || defaultLabels\n\n  const ratingProps = {\n    rangeCardinality,\n    name,\n    disabled,\n    onChange,\n    value,\n    cumulative,\n    defaultValue,\n    Icon,\n    ref,\n  }\n  return (\n    <FlexBox\n      {...(!showScaleLabels\n        ? {\n            css: css`\n              margin-top: 0.5rem;\n            `,\n          }\n        : {})}\n      itemsFlexEnd\n    >\n      {leadingHint && <RatingHint side=\"leading\">{leadingHint}</RatingHint>}\n      {showScaleLabels ? (\n        <span>\n          <FlexBox>\n            {labels.map((l, k) => (\n              <Text\n                key={l}\n                as=\"span\"\n                styledAs=\"bodyInterface\"\n                css={css`\n                  ${scaleSpacingCss}\n                  ${k === labels.length - 1 && `margin-right: 0;`}\n                  ${scaleLabelsSpacingCss}\n                  text-align: center;\n                  color: ${theme.colors.text.dark.secondary};\n                `}\n              >\n                {l}\n              </Text>\n            ))}\n          </FlexBox>\n          <RatingRow {...ratingProps} />\n        </span>\n      ) : (\n        <RatingRow {...ratingProps} />\n      )}\n      {trailingHint && <RatingHint side=\"trailing\">{trailingHint}</RatingHint>}\n    </FlexBox>\n  )\n}\n\nexport type RatingFieldProps = RatingProps &\n  Omit<FieldWrapProps, 'size' | 'placeholder' | 'helpPlacement' | 'children'> & {\n    size: Exclude<Size, 'large'>\n  }\n\n/**\n * The `RatingField` component will allow the user to provide feedback by ranking things on a specified scale.\n */\nexport const RatingField = ({\n  name,\n  label,\n  size,\n  errorMessage,\n  assistiveText,\n  hideAsterisk,\n  required,\n  rangeCardinality,\n  scaleLabels,\n  leadingHint,\n  trailingHint,\n  extraAssistiveText,\n  cumulative,\n  value,\n  help,\n  disabled,\n  onChange,\n  showScaleLabels,\n  defaultValue,\n  Icon,\n  className,\n  ref,\n}: RatingFieldProps) => {\n  return (\n    <FieldWrap\n      name={name}\n      label={label}\n      size={size}\n      errorMessage={errorMessage}\n      assistiveText={assistiveText}\n      extraAssistiveText={extraAssistiveText}\n      required={required}\n      help={help}\n      hideAsterisk={hideAsterisk}\n      disabled={disabled}\n      className={className}\n    >\n      <Rating\n        rangeCardinality={rangeCardinality}\n        scaleLabels={scaleLabels}\n        name={name}\n        leadingHint={leadingHint}\n        trailingHint={trailingHint}\n        value={value}\n        onChange={onChange}\n        disabled={disabled}\n        showScaleLabels={showScaleLabels}\n        cumulative={cumulative}\n        defaultValue={defaultValue}\n        Icon={Icon}\n        ref={ref}\n      />\n    </FieldWrap>\n  )\n}\n\nexport default RatingField\n"]} */"),
+          children: l
+        }, l))
+      }), (0, _jsxRuntime.jsx)(RatingRow, {
+        ...ratingProps
+      })]
+    }) : (0, _jsxRuntime.jsx)(RatingRow, {
+      ...ratingProps
+    }), trailingHint && (0, _jsxRuntime.jsx)(RatingHint, {
+      side: "trailing",
+      children: trailingHint
+    })]
+  });
+};
+exports.Rating = Rating;
+/**
+ * The `RatingField` component will allow the user to provide feedback by ranking things on a specified scale.
+ */
+const RatingField = ({
+  name,
+  label,
+  size,
+  errorMessage,
+  assistiveText,
+  hideAsterisk,
+  required,
+  rangeCardinality,
+  scaleLabels,
+  leadingHint,
+  trailingHint,
+  extraAssistiveText,
+  cumulative,
+  value,
+  help,
+  disabled,
+  onChange,
+  showScaleLabels,
+  defaultValue,
+  Icon,
+  className,
+  ref
+}) => {
+  return (0, _jsxRuntime.jsx)(_FieldWrap.FieldWrap, {
+    name: name,
+    label: label,
+    size: size,
+    errorMessage: errorMessage,
+    assistiveText: assistiveText,
+    extraAssistiveText: extraAssistiveText,
+    required: required,
+    help: help,
+    hideAsterisk: hideAsterisk,
+    disabled: disabled,
+    className: className,
+    children: (0, _jsxRuntime.jsx)(Rating, {
+      rangeCardinality: rangeCardinality,
+      scaleLabels: scaleLabels,
+      name: name,
+      leadingHint: leadingHint,
+      trailingHint: trailingHint,
+      value: value,
+      onChange: onChange,
+      disabled: disabled,
+      showScaleLabels: showScaleLabels,
+      cumulative: cumulative,
+      defaultValue: defaultValue,
+      Icon: Icon,
+      ref: ref
+    })
+  });
+};
+exports.RatingField = RatingField;
+var _default = exports.default = RatingField;

package/cjs/rating/index.d.ts

@@ -0,0 +1 @@
+export * from './Rating';

package/cjs/rating/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _Rating = require("./Rating");
+Object.keys(_Rating).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Rating[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Rating[key];
+    }
+  });
+});

package/cjs/select-field/AsyncSelectField.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { GroupBase } from 'react-select';
+import { AsyncProps } from 'react-select/async';
+import { BaseFieldProps } from '../types';
+type Size = 'small' | 'medium' | 'large';
+export type AsyncSelectFieldProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = BaseFieldProps & AsyncProps<Option, IsMulti, Group> & {
+    ref?: React.Ref<any>;
+    isClearable?: boolean;
+    value?: any;
+    visualSize?: Size;
+};
+declare const AsyncSelectFieldInner: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ assistiveText, components, disabled, errorMessage, help, helpPlacement, hideAsterisk, isClearable, label, name, onBlur, onChange, required, visualSize, ...rest }: AsyncSelectFieldProps<Option, IsMulti, Group>) => React.JSX.Element;
+export declare const AsyncSelectField: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: AsyncSelectFieldProps<Option, IsMulti, Group>) => ReturnType<typeof AsyncSelectFieldInner>;
+export default AsyncSelectField;

package/cjs/select-field/AsyncSelectField.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.AsyncSelectField = void 0;
+var _base = _interopRequireDefault(require("@emotion/styled/base"));
+var _react = _interopRequireDefault(require("react"));
+var _async = _interopRequireDefault(require("react-select/async"));
+var _AssistiveText = _interopRequireDefault(require("../assistive-text/AssistiveText"));
+var _ErrorText = _interopRequireDefault(require("../error-text/ErrorText"));
+var _HelpIcon = _interopRequireDefault(require("../help-icon/HelpIcon"));
+var _Label = require("../label/Label");
+var _flexbox = require("@dfds-ui/react-components/flexbox");
+var _react2 = require("@emotion/react");
+var _theme = require("@dfds-ui/theme");
+var _jsxRuntime = require("@emotion/react/jsx-runtime");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+const ReactSelectWrapper = /*#__PURE__*/(0, _base.default)("div", process.env.NODE_ENV === "production" ? {
+  target: "eeefs0"
+} : {
+  target: "eeefs0",
+  label: "ReactSelectWrapper"
+})("position:relative;[class$='-container']{&:has(span#aria-selection){[class$='-control']{border:1px solid ", p => p.error ? _theme.theme.colors.status.alert : _theme.theme.colors.secondary.main, ";box-shadow:inset 0 0 0 1px ", p => p.error ? _theme.theme.colors.status.alert : _theme.theme.colors.secondary.main, ";}[class$='-indicatorContainer']{color:", p => p.error ? _theme.theme.colors.status.alert : _theme.theme.colors.secondary.dark, ";}}[class$='-control']{border:1px solid ", _theme.theme.colors.text.dark.secondary, ";height:", p => p.size === 'small' && '32px' || p.size === 'medium' && '40px' || p.size === 'large' && '48px', ";min-height:", p => p.size === 'small' && '32px' || p.size === 'medium' && '40px' || p.size === 'large' && '48px', ";border-color:", p => p.error ? _theme.theme.colors.status.alert : p.disabled ? _theme.theme.colors.text.dark.disabled : _theme.theme.colors.text.dark.secondary, ";box-shadow:inset 0 0 0 ", p => p.error ? 1 : 0, "px ", _theme.theme.colors.status.alert, ";padding-left:5px;border-radius:0;font-family:", _theme.theme.fontFamilies.system, ";font-size:", p => p.size === 'large' && '1.125rem' || '1rem', ";appearance:none;cursor:pointer;background-color:", _theme.theme.colors.surface.primary, ";", _theme.media.lessThanEqual('m')`
+      font-size: 16px;
+    `, " &:hover{border:1px solid ", _theme.theme.colors.text.dark.primary, ";}}}[class$='-indicatorContainer']{color:", _theme.theme.colors.text.dark.secondary, ";}[class$='-indicatorSeparator']{display:none;}[class$='-placeholder']{opacity:", p => p.disabled ? 0.3 : 1, ";}[class$='-menu']{margin-top:0;margin-bottom:0;z-index:500000;}[class$='-option']{font-family:", _theme.theme.fontFamilies.system, ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
+var _ref = process.env.NODE_ENV === "production" ? {
+  name: "1a7e1yb",
+  styles: "margin-top:0.25rem"
+} : {
+  name: "1dql2sk-AsyncSelectFieldInner",
+  styles: "margin-top:0.25rem;label:AsyncSelectFieldInner;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+var _ref2 = process.env.NODE_ENV === "production" ? {
+  name: "1kk5tov",
+  styles: "flex:1;margin-bottom:0.25rem"
+} : {
+  name: "1a9lste-AsyncSelectFieldInner",
+  styles: "flex:1;margin-bottom:0.25rem;label:AsyncSelectFieldInner;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZWxlY3QtZmllbGQvQXN5bmNTZWxlY3RGaWVsZC50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBMEhvQiIsImZpbGUiOiIuLi8uLi8uLi9zcmMvc2VsZWN0LWZpZWxkL0FzeW5jU2VsZWN0RmllbGQudHN4Iiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgR3JvdXBCYXNlIH0gZnJvbSAncmVhY3Qtc2VsZWN0J1xuaW1wb3J0IEFzeW5jU2VsZWN0LCB7IEFzeW5jUHJvcHMgfSBmcm9tICdyZWFjdC1zZWxlY3QvYXN5bmMnXG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCdcblxuaW1wb3J0IEFzc2lzdGl2ZVRleHQgZnJvbSAnLi4vYXNzaXN0aXZlLXRleHQvQXNzaXN0aXZlVGV4dCdcbmltcG9ydCBFcnJvclRleHQgZnJvbSAnLi4vZXJyb3ItdGV4dC9FcnJvclRleHQnXG5pbXBvcnQgSGVscEljb24gZnJvbSAnLi4vaGVscC1pY29uL0hlbHBJY29uJ1xuaW1wb3J0IHsgTGFiZWwgfSBmcm9tICcuLi9sYWJlbC9MYWJlbCdcbmltcG9ydCB7IEZsZXhCb3ggfSBmcm9tICdAZGZkcy11aS9yZWFjdC1jb21wb25lbnRzL2ZsZXhib3gnXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCdcblxuaW1wb3J0IHsgQmFzZUZpZWxkUHJvcHMgfSBmcm9tICcuLi90eXBlcydcbmltcG9ydCB7IG1lZGlhLCB0aGVtZSB9IGZyb20gJ0BkZmRzLXVpL3RoZW1lJ1xuXG50eXBlIFNpemUgPSAnc21hbGwnIHwgJ21lZGl1bScgfCAnbGFyZ2UnXG5cbmNvbnN0IFJlYWN0U2VsZWN0V3JhcHBlciA9IHN0eWxlZC5kaXY8e1xuICBlcnJvcj86IGJvb2xlYW5cbiAgc2l6ZT86IHN0cmluZ1xuICBhcnJvdz86IGJvb2xlYW5cbiAgc2VsZWN0ZWQ/OiBib29sZWFuXG4gIGRpc2FibGVkPzogYm9vbGVhblxufT5gXG4gIHBvc2l0aW9uOiByZWxhdGl2ZTtcblxuICBbY2xhc3MkPSctY29udGFpbmVyJ10ge1xuICAgICY6aGFzKHNwYW4jYXJpYS1zZWxlY3Rpb24pIHtcbiAgICAgIFtjbGFzcyQ9Jy1jb250cm9sJ10ge1xuICAgICAgICBib3JkZXI6IDFweCBzb2xpZCAkeyhwKSA9PiAocC5lcnJvciA/IHRoZW1lLmNvbG9ycy5zdGF0dXMuYWxlcnQgOiB0aGVtZS5jb2xvcnMuc2Vjb25kYXJ5Lm1haW4pfTtcbiAgICAgICAgYm94LXNoYWRvdzogaW5zZXQgMCAwIDAgMXB4ICR7KHApID0+IChwLmVycm9yID8gdGhlbWUuY29sb3JzLnN0YXR1cy5hbGVydCA6IHRoZW1lLmNvbG9ycy5zZWNvbmRhcnkubWFpbil9O1xuICAgICAgfVxuICAgICAgW2NsYXNzJD0nLWluZGljYXRvckNvbnRhaW5lciddIHtcbiAgICAgICAgY29sb3I6ICR7KHApID0+IChwLmVycm9yID8gdGhlbWUuY29sb3JzLnN0YXR1cy5hbGVydCA6IHRoZW1lLmNvbG9ycy5zZWNvbmRhcnkuZGFyayl9O1xuICAgICAgfVxuICAgIH1cblxuICAgIFtjbGFzcyQ9Jy1jb250cm9sJ10ge1xuICAgICAgYm9yZGVyOiAxcHggc29saWQgJHt0aGVtZS5jb2xvcnMudGV4dC5kYXJrLnNlY29uZGFyeX07XG4gICAgICBoZWlnaHQ6ICR7KHApID0+XG4gICAgICAgIChwLnNpemUgPT09ICdzbWFsbCcgJiYgJzMycHgnKSB8fCAocC5zaXplID09PSAnbWVkaXVtJyAmJiAnNDBweCcpIHx8IChwLnNpemUgPT09ICdsYXJnZScgJiYgJzQ4cHgnKX07XG4gICAgICBtaW4taGVpZ2h0OiAkeyhwKSA9PlxuICAgICAgICAocC5zaXplID09PSAnc21hbGwnICYmICczMnB4JykgfHwgKHAuc2l6ZSA9PT0gJ21lZGl1bScgJiYgJzQwcHgnKSB8fCAocC5zaXplID09PSAnbGFyZ2UnICYmICc0OHB4Jyl9O1xuICAgICAgYm9yZGVyLWNvbG9yOiAkeyhwKSA9PlxuICAgICAgICBwLmVycm9yXG4gICAgICAgICAgPyB0aGVtZS5jb2xvcnMuc3RhdHVzLmFsZXJ0XG4gICAgICAgICAgOiBwLmRpc2FibGVkXG4gICAgICAgICAgICA/IHRoZW1lLmNvbG9ycy50ZXh0LmRhcmsuZGlzYWJsZWRcbiAgICAgICAgICAgIDogdGhlbWUuY29sb3JzLnRleHQuZGFyay5zZWNvbmRhcnl9O1xuICAgICAgYm94LXNoYWRvdzogaW5zZXQgMCAwIDAgJHsocCkgPT4gKHAuZXJyb3IgPyAxIDogMCl9cHggJHt0aGVtZS5jb2xvcnMuc3RhdHVzLmFsZXJ0fTtcbiAgICAgIHBhZGRpbmctbGVmdDogNXB4O1xuICAgICAgYm9yZGVyLXJhZGl1czogMDtcbiAgICAgIGZvbnQtZmFtaWx5OiAke3RoZW1lLmZvbnRGYW1pbGllcy5zeXN0ZW19O1xuICAgICAgZm9udC1zaXplOiAkeyhwKSA9PiAocC5zaXplID09PSAnbGFyZ2UnICYmICcxLjEyNXJlbScpIHx8ICcxcmVtJ307XG4gICAgICBhcHBlYXJhbmNlOiBub25lO1xuICAgICAgY3Vyc29yOiBwb2ludGVyO1xuICAgICAgYmFja2dyb3VuZC1jb2xvcjogJHt0aGVtZS5jb2xvcnMuc3VyZmFjZS5wcmltYXJ5fTtcblxuICAgICAgJHttZWRpYS5sZXNzVGhhbkVxdWFsKCdtJylgXG4gICAgICBmb250LXNpemU6IDE2cHg7XG4gICAgYH1cblxuICAgICAgJjpob3ZlciB7XG4gICAgICAgIGJvcmRlcjogMXB4IHNvbGlkICR7dGhlbWUuY29sb3JzLnRleHQuZGFyay5wcmltYXJ5fTtcbiAgICAgIH1cbiAgICB9XG4gIH1cblxuICBbY2xhc3MkPSctaW5kaWNhdG9yQ29udGFpbmVyJ10ge1xuICAgIGNvbG9yOiAke3RoZW1lLmNvbG9ycy50ZXh0LmRhcmsuc2Vjb25kYXJ5fTtcbiAgfVxuXG4gIFtjbGFzcyQ9Jy1pbmRpY2F0b3JTZXBhcmF0b3InXSB7XG4gICAgZGlzcGxheTogbm9uZTtcbiAgfVxuXG4gIFtjbGFzcyQ9Jy1wbGFjZWhvbGRlciddIHtcbiAgICBvcGFjaXR5OiAkeyhwKSA9PiAocC5kaXNhYmxlZCA/IDAuMyA6IDEpfTtcbiAgfVxuXG4gIFtjbGFzcyQ9Jy1tZW51J10ge1xuICAgIG1hcmdpbi10b3A6IDA7XG4gICAgbWFyZ2luLWJvdHRvbTogMDtcbiAgICB6LWluZGV4OiA1MDAwMDA7XG4gIH1cblxuICBbY2xhc3MkPSctb3B0aW9uJ10ge1xuICAgIGZvbnQtZmFtaWx5OiAke3RoZW1lLmZvbnRGYW1pbGllcy5zeXN0ZW19O1xuICB9XG5gXG5cbmV4cG9ydCB0eXBlIEFzeW5jU2VsZWN0RmllbGRQcm9wczxPcHRpb24sIElzTXVsdGkgZXh0ZW5kcyBib29sZWFuLCBHcm91cCBleHRlbmRzIEdyb3VwQmFzZTxPcHRpb24+PiA9IEJhc2VGaWVsZFByb3BzICZcbiAgQXN5bmNQcm9wczxPcHRpb24sIElzTXVsdGksIEdyb3VwPiAmIHtcbiAgICByZWY/OiBSZWFjdC5SZWY8YW55PlxuICAgIGlzQ2xlYXJhYmxlPzogYm9vbGVhblxuICAgIHZhbHVlPzogYW55XG4gICAgdmlzdWFsU2l6ZT86IFNpemVcbiAgfVxuXG5jb25zdCBBc3luY1NlbGVjdEZpZWxkSW5uZXIgPSA8T3B0aW9uLCBJc011bHRpIGV4dGVuZHMgYm9vbGVhbiwgR3JvdXAgZXh0ZW5kcyBHcm91cEJhc2U8T3B0aW9uPj4oe1xuICBhc3Npc3RpdmVUZXh0LFxuICBjb21wb25lbnRzLFxuICBkaXNhYmxlZCxcbiAgZXJyb3JNZXNzYWdlLFxuICBoZWxwLFxuICBoZWxwUGxhY2VtZW50ID0gJ3RvcCcsXG4gIGhpZGVBc3RlcmlzayxcbiAgaXNDbGVhcmFibGUgPSBmYWxzZSxcbiAgbGFiZWwsXG4gIG5hbWUsXG4gIG9uQmx1cixcbiAgb25DaGFuZ2UsXG4gIHJlcXVpcmVkLFxuICB2aXN1YWxTaXplID0gJ21lZGl1bScsXG5cbiAgLi4ucmVzdFxufTogQXN5bmNTZWxlY3RGaWVsZFByb3BzPE9wdGlvbiwgSXNNdWx0aSwgR3JvdXA+KSA9PiB7XG4gIHJldHVybiAoXG4gICAgPEZsZXhCb3ggZGlyZWN0aW9uQ29sdW1uPlxuICAgICAgPEZsZXhCb3ggaXRlbXNGbGV4U3RhcnQ+XG4gICAgICAgIHtsYWJlbCAmJiAoXG4gICAgICAgICAgPExhYmVsXG4gICAgICAgICAgICBjc3M9e2Nzc2BcbiAgICAgICAgICAgICAgZmxleDogMTtcbiAgICAgICAgICAgICAgbWFyZ2luLWJvdHRvbTogMC4yNXJlbTtcbiAgICAgICAgICAgIGB9XG4gICAgICAgICAgICBkaXNhYmxlZD17ZGlzYWJsZWR9XG4gICAgICAgICAgICBoaWRlQXN0ZXJpc2s9e2hpZGVBc3Rlcmlza31cbiAgICAgICAgICAgIHJlcXVpcmVkPXtyZXF1aXJlZH1cbiAgICAgICAgICAgIHZpc3VhbFNpemU9e3Zpc3VhbFNpemUgPT09ICdzbWFsbCcgPyAnc21hbGwnIDogJ21lZGl1bSd9XG4gICAgICAgICAgPlxuICAgICAgICAgICAge2xhYmVsfVxuICAgICAgICAgIDwvTGFiZWw+XG4gICAgICAgICl9XG5cbiAgICAgICAge2hlbHAgJiYgaGVscFBsYWNlbWVudCA9PT0gJ3RvcCcgPyA8SGVscEljb24gY29udGVudD17aGVscH0gLz4gOiB1bmRlZmluZWR9XG4gICAgICA8L0ZsZXhCb3g+XG4gICAgICA8UmVhY3RTZWxlY3RXcmFwcGVyXG4gICAgICAgIGVycm9yPXsoZXJyb3JNZXNzYWdlICYmIGVycm9yTWVzc2FnZS5sZW5ndGggPiAwKSB8fCB1bmRlZmluZWR9XG4gICAgICAgIHNpemU9e3Zpc3VhbFNpemV9XG4gICAgICAgIGRpc2FibGVkPXtkaXNhYmxlZH1cbiAgICAgICAgYXJyb3c9e3RydWV9XG4gICAgICA+XG4gICAgICAgIDxBc3luY1NlbGVjdFxuICAgICAgICAgIGlzQ2xlYXJhYmxlPXtpc0NsZWFyYWJsZX1cbiAgICAgICAgICBpc0Rpc2FibGVkPXtkaXNhYmxlZH1cbiAgICAgICAgICB7Li4ucmVzdH1cbiAgICAgICAgICBvbkNoYW5nZT17KG5ld1ZhbHVlLCBhY3Rpb25NZXRhKSA9PiB7XG4gICAgICAgICAgICBvbkNoYW5nZSAmJiBvbkNoYW5nZShuZXdWYWx1ZSwgYWN0aW9uTWV0YSlcbiAgICAgICAgICB9fVxuICAgICAgICAgIG9uQmx1cj17KGUpID0+IG9uQmx1ciAmJiBvbkJsdXIoZSl9XG4gICAgICAgIC8+XG4gICAgICA8L1JlYWN0U2VsZWN0V3JhcHBlcj5cblxuICAgICAgeyhhc3Npc3RpdmVUZXh0IHx8IGVycm9yTWVzc2FnZSkgJiYgKFxuICAgICAgICA8RmxleEJveFxuICAgICAgICAgIGNzcz17Y3NzYFxuICAgICAgICAgICAgbWFyZ2luLXRvcDogMC4yNXJlbTtcbiAgICAgICAgICBgfVxuICAgICAgICAgIHsuLi4oYXNzaXN0aXZlVGV4dCB8fCBlcnJvck1lc3NhZ2UgPyB7IGp1c3RpZnlTcGFjZUJldHdlZW46IHRydWUgfSA6IHsganVzdGlmeUZsZXhFbmQ6IHRydWUgfSl9XG4gICAgICAgID5cbiAgICAgICAgICB7YXNzaXN0aXZlVGV4dCAmJiAhZXJyb3JNZXNzYWdlICYmIChcbiAgICAgICAgICAgIDxBc3Npc3RpdmVUZXh0IGRpc2FibGVkPXtkaXNhYmxlZH0gaWQ9e25hbWUgKyAnX2FyaWEnfT5cbiAgICAgICAgICAgICAge2Fzc2lzdGl2ZVRleHR9XG4gICAgICAgICAgICA8L0Fzc2lzdGl2ZVRleHQ+XG4gICAgICAgICAgKX1cblxuICAgICAgICAgIHtlcnJvck1lc3NhZ2UgJiYgPEVycm9yVGV4dCBpZD17bmFtZSArICdfYXJpYSd9PntlcnJvck1lc3NhZ2V9PC9FcnJvclRleHQ+fVxuICAgICAgICA8L0ZsZXhCb3g+XG4gICAgICApfVxuICAgIDwvRmxleEJveD5cbiAgKVxufVxuXG5leHBvcnQgY29uc3QgQXN5bmNTZWxlY3RGaWVsZCA9IEFzeW5jU2VsZWN0RmllbGRJbm5lciBhcyA8XG4gIE9wdGlvbixcbiAgSXNNdWx0aSBleHRlbmRzIGJvb2xlYW4sXG4gIEdyb3VwIGV4dGVuZHMgR3JvdXBCYXNlPE9wdGlvbj4sXG4+KFxuICBwcm9wczogQXN5bmNTZWxlY3RGaWVsZFByb3BzPE9wdGlvbiwgSXNNdWx0aSwgR3JvdXA+XG4pID0+IFJldHVyblR5cGU8dHlwZW9mIEFzeW5jU2VsZWN0RmllbGRJbm5lcj5cblxuZXhwb3J0IGRlZmF1bHQgQXN5bmNTZWxlY3RGaWVsZFxuIl19 */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+const AsyncSelectFieldInner = ({
+  assistiveText,
+  components,
+  disabled,
+  errorMessage,
+  help,
+  helpPlacement = 'top',
+  hideAsterisk,
+  isClearable = false,
+  label,
+  name,
+  onBlur,
+  onChange,
+  required,
+  visualSize = 'medium',
+  ...rest
+}) => {
+  return (0, _jsxRuntime.jsxs)(_flexbox.FlexBox, {
+    directionColumn: true,
+    children: [(0, _jsxRuntime.jsxs)(_flexbox.FlexBox, {
+      itemsFlexStart: true,
+      children: [label && (0, _jsxRuntime.jsx)(_Label.Label, {
+        css: _ref2,
+        disabled: disabled,
+        hideAsterisk: hideAsterisk,
+        required: required,
+        visualSize: visualSize === 'small' ? 'small' : 'medium',
+        children: label
+      }), help && helpPlacement === 'top' ? (0, _jsxRuntime.jsx)(_HelpIcon.default, {
+        content: help
+      }) : undefined]
+    }), (0, _jsxRuntime.jsx)(ReactSelectWrapper, {
+      error: errorMessage && errorMessage.length > 0 || undefined,
+      size: visualSize,
+      disabled: disabled,
+      arrow: true,
+      children: (0, _jsxRuntime.jsx)(_async.default, {
+        isClearable: isClearable,
+        isDisabled: disabled,
+        ...rest,
+        onChange: (newValue, actionMeta) => {
+          onChange && onChange(newValue, actionMeta);
+        },
+        onBlur: e => onBlur && onBlur(e)
+      })
+    }), (assistiveText || errorMessage) && (0, _jsxRuntime.jsxs)(_flexbox.FlexBox, {
+      css: _ref,
+      ...(assistiveText || errorMessage ? {
+        justifySpaceBetween: true
+      } : {
+        justifyFlexEnd: true
+      }),
+      children: [assistiveText && !errorMessage && (0, _jsxRuntime.jsx)(_AssistiveText.default, {
+        disabled: disabled,
+        id: name + '_aria',
+        children: assistiveText
+      }), errorMessage && (0, _jsxRuntime.jsx)(_ErrorText.default, {
+        id: name + '_aria',
+        children: errorMessage
+      })]
+    })]
+  });
+};
+const AsyncSelectField = exports.AsyncSelectField = AsyncSelectFieldInner;
+var _default = exports.default = AsyncSelectField;

package/cjs/select-field/CreatableSelectField.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import { CreatableProps } from 'react-select/creatable';
+import { ActionMeta, createFilter, GroupBase, MultiValue, OptionsOrGroups, SingleValue } from 'react-select';
+import { BaseFieldProps } from '../types';
+type Size = 'small' | 'medium' | 'large';
+export type CreatableSelectFieldProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = BaseFieldProps & CreatableProps<Option, IsMulti, Group> & {
+    ref?: React.Ref<any>;
+    assistiveText?: string;
+    autoFocus?: boolean;
+    className?: string;
+    components?: any;
+    defaultValue?: SingleValue<Option>;
+    errorMessage?: string;
+    /**
+     * Configuration object passed to react-select createFilter function to create [custom filter
+     * logic](https://react-select.com/advanced#custom-filter-logic)
+     * @param ignoreCase - boolean (optional)
+     * @param ignoreAccents - boolean (optional)
+     * @param stringify (obj: any) => string (optional)
+     * @param trim - boolean (optional)
+     * @param matchForm - 'any' | 'start'
+     */
+    filterConfig?: Parameters<typeof createFilter>[0];
+    /**
+     * Indicates that the Select can be cleared after selecting an Option.
+     *
+     * Setting this to true will display a small dismiss cross when a value is selected
+     */
+    isClearable?: boolean;
+    isMulti?: boolean;
+    isSearchable?: boolean;
+    menuIsOpen?: boolean;
+    menuPlacement?: 'bottom' | 'auto' | 'top';
+    onBlur?: (value: any) => void;
+    onChange?: (newValue: SingleValue<Option> | MultiValue<Option>, actionMeta: ActionMeta<Option>) => void;
+    onSelect?: (value: SingleValue<Option> | MultiValue<Option>) => void;
+    options?: OptionsOrGroups<Option, GroupBase<Option>>;
+    placeholder?: string;
+    prefix?: React.ReactNode;
+    styles?: any;
+    suffix?: React.ReactNode;
+    value?: SingleValue<Option> | MultiValue<Option>;
+    visualSize?: Size;
+};
+declare const CreatableSelectFieldInner: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ assistiveText, components, defaultValue, disabled, errorMessage, filterConfig, help, helpPlacement, hideAsterisk, isClearable, isMulti, isSearchable, label, name, onBlur, onChange, onSelect, options, placeholder, required, styles, value, visualSize, ...rest }: CreatableSelectFieldProps<Option, IsMulti, Group>) => React.JSX.Element;
+export declare const CreatableSelectField: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: CreatableSelectFieldProps<Option, IsMulti, Group>) => ReturnType<typeof CreatableSelectFieldInner>;
+export default CreatableSelectField;