@mycause/ui 0.0.0-c4be5cf7 → 0.0.0-c4d5b14e

package/donation/esm/components/text/text.js

@@ -0,0 +1,189 @@
+import { objectWithoutProperties as _objectWithoutProperties, extends as _extends } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import _JSXStyle from 'styled-jsx/style';
+import React, { forwardRef } from 'react';
+import classnames from 'classnames';
+import { useTheme, getColorToken } from '../../theme/theme.js';
+import { flags } from '../../utils/flags.js';
+import { wrap } from '../../utils/wrap.js';
+import Box from '../layout/box.js';
+
+const _excluded = ["elem", "kind", "font", "align", "h1", "h2", "h3", "h4", "h5", "h6", "p", "small", "span", "underline", "strike", "bold", "italic", "color", "invert", "children", "className"];
+// Wrap the text in modifier elements like bold or italic
+function addWrappers(node, _ref) {
+  let {
+    underline,
+    strike,
+    bold,
+    italic
+  } = _ref;
+  let result = node;
+  result = wrap(result, "u", underline);
+  result = wrap(result, "s", strike);
+  result = wrap(result, "b", bold);
+  result = wrap(result, "i", italic);
+  return result;
+}
+
+// All text presets
+
+const kinds = {
+  display1: `
+    font-size: 3rem;
+    line-height: 3.5rem;
+  `,
+  display2: `
+    font-size: 2.25rem;
+    line-height: 3rem;
+  `,
+  h1: `
+    font-size: 2.25rem;
+    line-height: 3rem;
+    font-weight: bold;
+  `,
+  h2: `
+    font-size: 1.75rem;
+    line-height: 2rem;
+    font-weight: bold;
+  `,
+  h3: `
+    font-size: 1.25rem;
+    line-height: 2rem;
+    font-weight: bold;
+  `,
+  h4: `
+    font-size: 1rem;
+    line-height: 1.5rem;
+    font-weight: bold;
+  `,
+  h5: `
+    font-size: 0.875rem;
+    line-height: 1.5rem;
+    font-weight: bold;
+  `,
+  h6: `
+    font-size: 0.875rem;
+    line-height: 1.5rem;
+    font-weight: bold;
+  `,
+  p: `
+    font-size: 1rem;
+    line-height: 1.5rem;
+  `,
+  sub: `
+    font-size: 0.875rem;
+    line-height: 1.25rem;
+  `,
+  small: `
+    font-size: 0.75rem;
+    line-height: 1.25rem;
+  `,
+  fine: `
+    font-size: 0.675rem;
+    line-height: 1rem;
+  `,
+  span: ``
+};
+
+// Supported text elements
+// If you need to use a different element, consider just wrapping a span type <Text/> in
+// that element
+
+// Text ref types
+// this is necessary because heading elements have different attributes
+
+const Text = /*#__PURE__*/forwardRef(function Text(_ref2, ref) {
+  let {
+      elem: element,
+      kind,
+      font,
+      align,
+      // component types
+      h1,
+      h2,
+      h3,
+      h4,
+      h5,
+      h6,
+      p,
+      small,
+      span,
+      // modifiers
+      underline,
+      strike,
+      bold,
+      italic,
+      // color
+      color,
+      invert,
+      //
+      children,
+      className
+    } = _ref2,
+    rest = _objectWithoutProperties(_ref2, _excluded);
+  const theme = useTheme();
+
+  // Process component type flags, defaulting to span
+  element = flags({
+    h1,
+    h2,
+    h3,
+    h4,
+    h5,
+    h6,
+    p,
+    small,
+    span
+  }, element || "span");
+
+  // If no kind is specified, just use the kind named after the element
+  kind = kind || element;
+
+  // Headings are already bold so prevent wrapping an extra <b> element
+  if (isHeading(element) && bold) {
+    bold = false;
+  }
+
+  // The h6 style has a different color by default
+  if (kind === "h6") {
+    color = color || "muted";
+  }
+  const foreground = color || invert ? getColorToken(theme, "foreground", color || "neutral", {
+    invert
+  }) : "inherit";
+  const fontFamily = font ? theme.typography.fontFamily[font] : "inherit";
+  const scope = {
+    styles: /*#__PURE__*/React.createElement(_JSXStyle, {
+      id: "4251138725",
+      dynamic: [element, fontFamily, foreground, kinds[kind], align]
+    }, `${element}.__jsx-style-dynamic-selector{font-weight:initial;font-family:${fontFamily};color:${foreground};${kinds[kind]} margin:0;}.unbold.__jsx-style-dynamic-selector{font-weight:400;}.align.__jsx-style-dynamic-selector{text-align:${align};}
+/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */
+/*@ sourceURL=text.tsx */`),
+    className: _JSXStyle.dynamic([["4251138725", [element, fontFamily, foreground, kinds[kind], align]]])
+  };
+  return /*#__PURE__*/React.createElement(Box, _extends({
+    as: element
+  }, rest, {
+    className: classnames(className, {
+      unbold: isHeading(element) && bold === false,
+      align: align
+    }, scope.className)
+    // The following error is caused by the fact that the element rendered
+    // could be either a HTMLElement or HTMLHeadingElement but it cannot know
+    // which at runtime. In practice the difference between the two elements
+    // never really arises as an issue.
+    // @ts-ignore: error
+    ,
+    ref: ref
+  }), addWrappers(children, {
+    underline,
+    strike,
+    bold,
+    italic
+  }), scope.styles);
+});
+function isHeading(kind) {
+  return kind.startsWith("h");
+}
+var Text$1 = Text;
+
+export { Text$1 as default };

package/donation/esm/components/text-field/text-field-helper-text.js

@@ -0,0 +1,24 @@
+import { objectWithoutProperties as _objectWithoutProperties, extends as _extends } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import _pt from 'prop-types';
+import React from 'react';
+import { HelperText as HelperText$1 } from '@material/react-text-field';
+
+const _excluded = ["error", "children"];
+function HelperText(_ref) {
+  let {
+      error,
+      children
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  return /*#__PURE__*/React.createElement(HelperText$1, _extends({
+    isValid: !error,
+    isValidationMessage: !!error,
+    validation: !!error
+  }, props), error ? error : children || null);
+}
+HelperText.propTypes = {
+  error: _pt.string,
+  children: _pt.node
+};
+
+export { HelperText as default };

package/donation/esm/components/text-field/text-field.js

@@ -0,0 +1,159 @@
+import { objectWithoutProperties as _objectWithoutProperties, extends as _extends } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import _pt from 'prop-types';
+import _JSXStyle from 'styled-jsx/style';
+import React, { forwardRef, useCallback } from 'react';
+import classnames from 'classnames';
+import MDCTextField, { Input } from '@material/react-text-field';
+import { setRef } from '../../utils/set-ref.js';
+import { isInternetExplorer } from '../../utils/browser.js';
+import { useTheme } from '../../theme/theme.js';
+import HelperText from './text-field-helper-text.js';
+
+const _excluded = ["fullWidth", "helperText", "isHelperTextPersistent", "characterCounter", "label", "leadingIcon", "onLeadingIconSelect", "onTrailingIconSelect", "textarea", "trailingIcon", "large", "error", "externalLabel", "id", "required", "placeholder", "className", "color", "outlined"];
+const TextField = /*#__PURE__*/forwardRef(function TextField(_ref, ref_) {
+  let {
+      fullWidth,
+      helperText,
+      isHelperTextPersistent,
+      characterCounter,
+      label,
+      leadingIcon,
+      onLeadingIconSelect,
+      onTrailingIconSelect,
+      textarea,
+      trailingIcon,
+      large,
+      error,
+      externalLabel,
+      id,
+      required,
+      placeholder,
+      className,
+      color,
+      outlined = true
+    } = _ref,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  const theme = useTheme();
+  let noLabel = false; // nolabel turns the provided label into a placeholder
+  let externalLabelContents = null;
+
+  // The floating label has a visual bug in Internet Explorer so we use the external label instead
+  if (isInternetExplorer()) {
+    externalLabel = true;
+  }
+
+  // If helperText is passed as a string turn it into a HelperText
+  // If there is an error, it gets rendered into the HelperText
+  // use isHelperTextPersistent to ensure the HelperText is always
+  // rendered and takes up space for layout reasons.
+  if (typeof helperText === "string" || isHelperTextPersistent || error && typeof error !== "boolean") {
+    helperText = /*#__PURE__*/React.createElement(HelperText, {
+      persistent: isHelperTextPersistent
+    }, helperText);
+  }
+
+  // Override the HelperText when there is an error
+  // When error is a boolean that means we just update the styling of the field,
+  // the helper text does not change
+  if (error && typeof error !== "boolean") {
+    helperText = /*#__PURE__*/React.cloneElement(helperText, {
+      error
+    });
+  }
+
+  // Apply externalLabel
+  if (externalLabel) {
+    externalLabelContents = label;
+    label = undefined;
+  }
+
+  // Add the placeholder
+  if (placeholder) {
+    if (!externalLabel) {
+      externalLabelContents = label; // you can't have a floating label and a placeholder at the same time
+    }
+    label = placeholder;
+    noLabel = true;
+  }
+  const props = {
+    outlined,
+    dense: !large,
+    fullWidth,
+    helperText: helperText,
+    characterCounter,
+    label,
+    leadingIcon,
+    onLeadingIconSelect,
+    onTrailingIconSelect,
+    textarea,
+    trailingIcon,
+    id,
+    noLabel
+  };
+
+  // useCallback to ensure there is a stable ref
+  // The <Input> component has an `inputElement` property which holds
+  // the underlying input element node
+  const ref = useCallback(setRef(ref_, instance => instance.inputElement), [ref_]);
+  const scope = {
+    styles: /*#__PURE__*/React.createElement(_JSXStyle, {
+      id: "1853319237",
+      dynamic: [color ? "--mdc-theme-primary: " + color + ";" : "", color ? "--mdc-theme-secondary: " + color + ";" : "", color, theme.typography.fontFamily.brand]
+    }, `.text-field.__jsx-style-dynamic-selector{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;${color ? "--mdc-theme-primary: " + color + ";" : ""} ${color ? "--mdc-theme-secondary: " + color + ";" : ""};}.text-field.__jsx-style-dynamic-selector .mdc-floating-label--float-above{color:${color}!important;}.text-field.__jsx-style-dynamic-selector .mdc-text-field__input,.text-field.__jsx-style-dynamic-selector .mdc-floating-label,.text-field.__jsx-style-dynamic-selector .mdc-text-field-helper-text{font-weight:500;font-family:${theme.typography.fontFamily.brand};}
+/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["text-field.tsx"],"names":[],"mappings":"AA4I6B,AAGsB,AAMgC,AAK7B,gBACyB,6BAL3C,YAMA,iBAZwB,8EAGzB,0DAAC","file":"text-field.tsx","sourcesContent":["import React, { forwardRef, useCallback } from \"react\";\nimport cn from \"classnames\";\nimport css from \"styled-jsx/css\";\nimport MDCTextField, { Input } from \"@material/react-text-field\";\nimport { CharacterCounterProps } from \"@material/react-text-field/character-counter\";\nimport { setRef } from \"../../utils/set-ref\";\nimport { isInternetExplorer } from \"../../utils/browser\";\nimport { useTheme } from \"../../theme/theme\";\nimport HelperText, { HelperTextProps } from \"./text-field-helper-text\";\n\nexport interface TextFieldProps\n  extends Omit<React.HTMLProps<HTMLInputElement>, \"ref\" | \"dense\"> {\n  // props from the material text field\n  fullWidth?: boolean;\n  helperText?: string | React.ReactElement<HelperTextProps> | null;\n  characterCounter?: React.ReactElement<CharacterCounterProps>;\n  label?: string;\n  leadingIcon?: React.ReactElement;\n  onLeadingIconSelect?: () => void;\n  onTrailingIconSelect?: () => void;\n  textarea?: boolean;\n  trailingIcon?: React.ReactElement;\n  // added props\n  isHelperTextPersistent?: boolean;\n  large?: boolean;\n  error?: string | null | boolean;\n  externalLabel?: boolean;\n  placeholder?: string;\n  list?: string;\n  // to be passed on to the input\n  className?: string;\n  required?: boolean;\n  color?: string;\n  outlined?: boolean;\n  onChange?: (e: React.FormEvent<HTMLInputElement>) => void;\n}\n\nconst TextField = forwardRef<HTMLInputElement, TextFieldProps>(\n  function TextField(\n    {\n      fullWidth,\n      helperText,\n      isHelperTextPersistent,\n      characterCounter,\n      label,\n      leadingIcon,\n      onLeadingIconSelect,\n      onTrailingIconSelect,\n      textarea,\n      trailingIcon,\n      large,\n      error,\n      externalLabel,\n      id,\n      required,\n      placeholder,\n      className,\n      color,\n      outlined = true,\n      ...rest\n    }: TextFieldProps,\n    ref_: React.Ref<HTMLInputElement>\n  ) {\n    const theme = useTheme();\n\n    let noLabel = false; // nolabel turns the provided label into a placeholder\n    let externalLabelContents = null;\n\n    // The floating label has a visual bug in Internet Explorer so we use the external label instead\n    if (isInternetExplorer()) {\n      externalLabel = true;\n    }\n\n    // If helperText is passed as a string turn it into a HelperText\n    // If there is an error, it gets rendered into the HelperText\n    // use isHelperTextPersistent to ensure the HelperText is always\n    // rendered and takes up space for layout reasons.\n    if (\n      typeof helperText === \"string\" ||\n      isHelperTextPersistent ||\n      (error && typeof error !== \"boolean\")\n    ) {\n      helperText = (\n        <HelperText persistent={isHelperTextPersistent}>\n          {helperText}\n        </HelperText>\n      );\n    }\n\n    // Override the HelperText when there is an error\n    // When error is a boolean that means we just update the styling of the field,\n    // the helper text does not change\n    if (error && typeof error !== \"boolean\") {\n      helperText = React.cloneElement(helperText!, {\n        error,\n      });\n    }\n\n    // Apply externalLabel\n    if (externalLabel) {\n      externalLabelContents = label;\n      label = undefined;\n    }\n\n    // Add the placeholder\n    if (placeholder) {\n      if (!externalLabel) {\n        externalLabelContents = label; // you can't have a floating label and a placeholder at the same time\n      }\n      label = placeholder;\n      noLabel = true;\n    }\n\n    const props = {\n      outlined,\n      dense: !large,\n      fullWidth,\n      helperText: helperText as React.ReactElement,\n      characterCounter,\n      label,\n      leadingIcon,\n      onLeadingIconSelect,\n      onTrailingIconSelect,\n      textarea,\n      trailingIcon,\n      id,\n      noLabel,\n    };\n\n    // useCallback to ensure there is a stable ref\n    // The <Input> component has an `inputElement` property which holds\n    // the underlying input element node\n    const ref = useCallback(\n      setRef<HTMLInputElement, Input<HTMLInputElement>>(\n        ref_,\n        instance => instance.inputElement\n      ),\n      [ref_]\n    );\n\n    const scope = css.resolve`\n      .text-field {\n        display: flex;\n        flex-direction: column;\n        ${color ? \"--mdc-theme-primary: \" + color + \";\" : \"\"}\n        ${color ? \"--mdc-theme-secondary: \" + color + \";\" : \"\"}\n      }\n      .text-field :global(.mdc-floating-label--float-above) {\n        color: ${color}!important;\n      }\n      .text-field :global(.mdc-text-field__input),\n      .text-field :global(.mdc-floating-label),\n      .text-field :global(.mdc-text-field-helper-text) {\n        font-weight: 500;\n        font-family: ${theme.typography.fontFamily.brand};\n      }\n    `;\n\n    return (\n      <div className={cn(\"text-field\", className, scope.className)}>\n        {externalLabelContents ? (\n          <ExternalLabel\n            id={id}\n            required={required}\n            dense={!large}\n            color={color}\n          >\n            {externalLabelContents}\n          </ExternalLabel>\n        ) : null}\n        <MDCTextField {...props}>\n          <Input\n            inputType={textarea ? \"textarea\" : \"input\"}\n            isValid={!error}\n            id={id}\n            required={required}\n            ref={ref}\n            {...rest}\n          />\n        </MDCTextField>\n        {scope.styles}\n      </div>\n    );\n  }\n);\n\ninterface ExternalLabelProps {\n  id?: string;\n  dense?: boolean;\n  required?: boolean;\n  color?: string;\n  children?: React.ReactNode;\n}\n\nfunction ExternalLabel({\n  id,\n  dense,\n  required,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  color,\n  children,\n}: ExternalLabelProps) {\n  const theme = useTheme();\n\n  const scope = css.resolve`\n    .text-field-label {\n      font-family: ${theme.typography.fontFamily.brand};\n      font-weight: 500;\n    }\n  `;\n\n  return (\n    <label\n      className={cn(\n        \"text-field-label\",\n        {\n          \"text-field-label--dense\": dense,\n        },\n        scope.className\n      )}\n      htmlFor={id}\n    >\n      {children}\n      {required ? \"*\" : \"\"}\n      <style jsx>{`\n        .text-field-label {\n          font-size: 0.875rem;\n          font-weight: 500;\n          margin: 0.5rem 0;\n          display: inline-block;\n          font-weight: 400;\n          letter-spacing: 0.00937em;\n          color: rgba(0, 0, 0, 0.6);\n          text-align: left;\n          line-height: 1rem;\n        }\n\n        .text-field-label--dense {\n          font-size: 0.75rem;\n        }\n      `}</style>\n      {scope.styles}\n    </label>\n  );\n}\n\nexport default TextField;\n"]} */
+/*@ sourceURL=text-field.tsx */`),
+    className: _JSXStyle.dynamic([["1853319237", [color ? "--mdc-theme-primary: " + color + ";" : "", color ? "--mdc-theme-secondary: " + color + ";" : "", color, theme.typography.fontFamily.brand]]])
+  };
+  return /*#__PURE__*/React.createElement("div", {
+    className: classnames("text-field", className, scope.className)
+  }, externalLabelContents ? /*#__PURE__*/React.createElement(ExternalLabel, {
+    id: id,
+    required: required,
+    dense: !large,
+    color: color
+  }, externalLabelContents) : null, /*#__PURE__*/React.createElement(MDCTextField, props, /*#__PURE__*/React.createElement(Input, _extends({
+    inputType: textarea ? "textarea" : "input",
+    isValid: !error,
+    id: id,
+    required: required,
+    ref: ref
+  }, rest))), scope.styles);
+});
+function ExternalLabel(_ref2) {
+  let {
+    id,
+    dense,
+    required,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    color,
+    children
+  } = _ref2;
+  const theme = useTheme();
+  const scope = {
+    styles: /*#__PURE__*/React.createElement(_JSXStyle, {
+      id: "853432101",
+      dynamic: [theme.typography.fontFamily.brand]
+    }, `.text-field-label.__jsx-style-dynamic-selector{font-family:${theme.typography.fontFamily.brand};font-weight:500;}
+/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["text-field.tsx"],"names":[],"mappings":"AA4M2B,AAGgD,yCACzB,gBAClB","file":"text-field.tsx","sourcesContent":["import React, { forwardRef, useCallback } from \"react\";\nimport cn from \"classnames\";\nimport css from \"styled-jsx/css\";\nimport MDCTextField, { Input } from \"@material/react-text-field\";\nimport { CharacterCounterProps } from \"@material/react-text-field/character-counter\";\nimport { setRef } from \"../../utils/set-ref\";\nimport { isInternetExplorer } from \"../../utils/browser\";\nimport { useTheme } from \"../../theme/theme\";\nimport HelperText, { HelperTextProps } from \"./text-field-helper-text\";\n\nexport interface TextFieldProps\n  extends Omit<React.HTMLProps<HTMLInputElement>, \"ref\" | \"dense\"> {\n  // props from the material text field\n  fullWidth?: boolean;\n  helperText?: string | React.ReactElement<HelperTextProps> | null;\n  characterCounter?: React.ReactElement<CharacterCounterProps>;\n  label?: string;\n  leadingIcon?: React.ReactElement;\n  onLeadingIconSelect?: () => void;\n  onTrailingIconSelect?: () => void;\n  textarea?: boolean;\n  trailingIcon?: React.ReactElement;\n  // added props\n  isHelperTextPersistent?: boolean;\n  large?: boolean;\n  error?: string | null | boolean;\n  externalLabel?: boolean;\n  placeholder?: string;\n  list?: string;\n  // to be passed on to the input\n  className?: string;\n  required?: boolean;\n  color?: string;\n  outlined?: boolean;\n  onChange?: (e: React.FormEvent<HTMLInputElement>) => void;\n}\n\nconst TextField = forwardRef<HTMLInputElement, TextFieldProps>(\n  function TextField(\n    {\n      fullWidth,\n      helperText,\n      isHelperTextPersistent,\n      characterCounter,\n      label,\n      leadingIcon,\n      onLeadingIconSelect,\n      onTrailingIconSelect,\n      textarea,\n      trailingIcon,\n      large,\n      error,\n      externalLabel,\n      id,\n      required,\n      placeholder,\n      className,\n      color,\n      outlined = true,\n      ...rest\n    }: TextFieldProps,\n    ref_: React.Ref<HTMLInputElement>\n  ) {\n    const theme = useTheme();\n\n    let noLabel = false; // nolabel turns the provided label into a placeholder\n    let externalLabelContents = null;\n\n    // The floating label has a visual bug in Internet Explorer so we use the external label instead\n    if (isInternetExplorer()) {\n      externalLabel = true;\n    }\n\n    // If helperText is passed as a string turn it into a HelperText\n    // If there is an error, it gets rendered into the HelperText\n    // use isHelperTextPersistent to ensure the HelperText is always\n    // rendered and takes up space for layout reasons.\n    if (\n      typeof helperText === \"string\" ||\n      isHelperTextPersistent ||\n      (error && typeof error !== \"boolean\")\n    ) {\n      helperText = (\n        <HelperText persistent={isHelperTextPersistent}>\n          {helperText}\n        </HelperText>\n      );\n    }\n\n    // Override the HelperText when there is an error\n    // When error is a boolean that means we just update the styling of the field,\n    // the helper text does not change\n    if (error && typeof error !== \"boolean\") {\n      helperText = React.cloneElement(helperText!, {\n        error,\n      });\n    }\n\n    // Apply externalLabel\n    if (externalLabel) {\n      externalLabelContents = label;\n      label = undefined;\n    }\n\n    // Add the placeholder\n    if (placeholder) {\n      if (!externalLabel) {\n        externalLabelContents = label; // you can't have a floating label and a placeholder at the same time\n      }\n      label = placeholder;\n      noLabel = true;\n    }\n\n    const props = {\n      outlined,\n      dense: !large,\n      fullWidth,\n      helperText: helperText as React.ReactElement,\n      characterCounter,\n      label,\n      leadingIcon,\n      onLeadingIconSelect,\n      onTrailingIconSelect,\n      textarea,\n      trailingIcon,\n      id,\n      noLabel,\n    };\n\n    // useCallback to ensure there is a stable ref\n    // The <Input> component has an `inputElement` property which holds\n    // the underlying input element node\n    const ref = useCallback(\n      setRef<HTMLInputElement, Input<HTMLInputElement>>(\n        ref_,\n        instance => instance.inputElement\n      ),\n      [ref_]\n    );\n\n    const scope = css.resolve`\n      .text-field {\n        display: flex;\n        flex-direction: column;\n        ${color ? \"--mdc-theme-primary: \" + color + \";\" : \"\"}\n        ${color ? \"--mdc-theme-secondary: \" + color + \";\" : \"\"}\n      }\n      .text-field :global(.mdc-floating-label--float-above) {\n        color: ${color}!important;\n      }\n      .text-field :global(.mdc-text-field__input),\n      .text-field :global(.mdc-floating-label),\n      .text-field :global(.mdc-text-field-helper-text) {\n        font-weight: 500;\n        font-family: ${theme.typography.fontFamily.brand};\n      }\n    `;\n\n    return (\n      <div className={cn(\"text-field\", className, scope.className)}>\n        {externalLabelContents ? (\n          <ExternalLabel\n            id={id}\n            required={required}\n            dense={!large}\n            color={color}\n          >\n            {externalLabelContents}\n          </ExternalLabel>\n        ) : null}\n        <MDCTextField {...props}>\n          <Input\n            inputType={textarea ? \"textarea\" : \"input\"}\n            isValid={!error}\n            id={id}\n            required={required}\n            ref={ref}\n            {...rest}\n          />\n        </MDCTextField>\n        {scope.styles}\n      </div>\n    );\n  }\n);\n\ninterface ExternalLabelProps {\n  id?: string;\n  dense?: boolean;\n  required?: boolean;\n  color?: string;\n  children?: React.ReactNode;\n}\n\nfunction ExternalLabel({\n  id,\n  dense,\n  required,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  color,\n  children,\n}: ExternalLabelProps) {\n  const theme = useTheme();\n\n  const scope = css.resolve`\n    .text-field-label {\n      font-family: ${theme.typography.fontFamily.brand};\n      font-weight: 500;\n    }\n  `;\n\n  return (\n    <label\n      className={cn(\n        \"text-field-label\",\n        {\n          \"text-field-label--dense\": dense,\n        },\n        scope.className\n      )}\n      htmlFor={id}\n    >\n      {children}\n      {required ? \"*\" : \"\"}\n      <style jsx>{`\n        .text-field-label {\n          font-size: 0.875rem;\n          font-weight: 500;\n          margin: 0.5rem 0;\n          display: inline-block;\n          font-weight: 400;\n          letter-spacing: 0.00937em;\n          color: rgba(0, 0, 0, 0.6);\n          text-align: left;\n          line-height: 1rem;\n        }\n\n        .text-field-label--dense {\n          font-size: 0.75rem;\n        }\n      `}</style>\n      {scope.styles}\n    </label>\n  );\n}\n\nexport default TextField;\n"]} */
+/*@ sourceURL=text-field.tsx */`),
+    className: _JSXStyle.dynamic([["853432101", [theme.typography.fontFamily.brand]]])
+  };
+  return /*#__PURE__*/React.createElement("label", {
+    htmlFor: id,
+    className: "jsx-4070017608" + " " + (classnames("text-field-label", {
+      "text-field-label--dense": dense
+    }, scope.className) || "")
+  }, children, required ? "*" : "", /*#__PURE__*/React.createElement(_JSXStyle, {
+    id: "4070017608"
+  }, ".text-field-label.jsx-4070017608{font-size:0.875rem;font-weight:500;margin:0.5rem 0;display:inline-block;font-weight:400;-webkit-letter-spacing:0.00937em;-moz-letter-spacing:0.00937em;-ms-letter-spacing:0.00937em;letter-spacing:0.00937em;color:rgba(0,0,0,0.6);text-align:left;line-height:1rem;}.text-field-label--dense.jsx-4070017608{font-size:0.75rem;}\n/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["text-field.tsx"],"names":[],"mappings":"AAgOkB,AAG8B,AAYD,kBACpB,CAZkB,gBACA,gBACK,qBACL,gBACS,qHACA,sBACT,gBACC,iBACnB","file":"text-field.tsx","sourcesContent":["import React, { forwardRef, useCallback } from \"react\";\nimport cn from \"classnames\";\nimport css from \"styled-jsx/css\";\nimport MDCTextField, { Input } from \"@material/react-text-field\";\nimport { CharacterCounterProps } from \"@material/react-text-field/character-counter\";\nimport { setRef } from \"../../utils/set-ref\";\nimport { isInternetExplorer } from \"../../utils/browser\";\nimport { useTheme } from \"../../theme/theme\";\nimport HelperText, { HelperTextProps } from \"./text-field-helper-text\";\n\nexport interface TextFieldProps\n  extends Omit<React.HTMLProps<HTMLInputElement>, \"ref\" | \"dense\"> {\n  // props from the material text field\n  fullWidth?: boolean;\n  helperText?: string | React.ReactElement<HelperTextProps> | null;\n  characterCounter?: React.ReactElement<CharacterCounterProps>;\n  label?: string;\n  leadingIcon?: React.ReactElement;\n  onLeadingIconSelect?: () => void;\n  onTrailingIconSelect?: () => void;\n  textarea?: boolean;\n  trailingIcon?: React.ReactElement;\n  // added props\n  isHelperTextPersistent?: boolean;\n  large?: boolean;\n  error?: string | null | boolean;\n  externalLabel?: boolean;\n  placeholder?: string;\n  list?: string;\n  // to be passed on to the input\n  className?: string;\n  required?: boolean;\n  color?: string;\n  outlined?: boolean;\n  onChange?: (e: React.FormEvent<HTMLInputElement>) => void;\n}\n\nconst TextField = forwardRef<HTMLInputElement, TextFieldProps>(\n  function TextField(\n    {\n      fullWidth,\n      helperText,\n      isHelperTextPersistent,\n      characterCounter,\n      label,\n      leadingIcon,\n      onLeadingIconSelect,\n      onTrailingIconSelect,\n      textarea,\n      trailingIcon,\n      large,\n      error,\n      externalLabel,\n      id,\n      required,\n      placeholder,\n      className,\n      color,\n      outlined = true,\n      ...rest\n    }: TextFieldProps,\n    ref_: React.Ref<HTMLInputElement>\n  ) {\n    const theme = useTheme();\n\n    let noLabel = false; // nolabel turns the provided label into a placeholder\n    let externalLabelContents = null;\n\n    // The floating label has a visual bug in Internet Explorer so we use the external label instead\n    if (isInternetExplorer()) {\n      externalLabel = true;\n    }\n\n    // If helperText is passed as a string turn it into a HelperText\n    // If there is an error, it gets rendered into the HelperText\n    // use isHelperTextPersistent to ensure the HelperText is always\n    // rendered and takes up space for layout reasons.\n    if (\n      typeof helperText === \"string\" ||\n      isHelperTextPersistent ||\n      (error && typeof error !== \"boolean\")\n    ) {\n      helperText = (\n        <HelperText persistent={isHelperTextPersistent}>\n          {helperText}\n        </HelperText>\n      );\n    }\n\n    // Override the HelperText when there is an error\n    // When error is a boolean that means we just update the styling of the field,\n    // the helper text does not change\n    if (error && typeof error !== \"boolean\") {\n      helperText = React.cloneElement(helperText!, {\n        error,\n      });\n    }\n\n    // Apply externalLabel\n    if (externalLabel) {\n      externalLabelContents = label;\n      label = undefined;\n    }\n\n    // Add the placeholder\n    if (placeholder) {\n      if (!externalLabel) {\n        externalLabelContents = label; // you can't have a floating label and a placeholder at the same time\n      }\n      label = placeholder;\n      noLabel = true;\n    }\n\n    const props = {\n      outlined,\n      dense: !large,\n      fullWidth,\n      helperText: helperText as React.ReactElement,\n      characterCounter,\n      label,\n      leadingIcon,\n      onLeadingIconSelect,\n      onTrailingIconSelect,\n      textarea,\n      trailingIcon,\n      id,\n      noLabel,\n    };\n\n    // useCallback to ensure there is a stable ref\n    // The <Input> component has an `inputElement` property which holds\n    // the underlying input element node\n    const ref = useCallback(\n      setRef<HTMLInputElement, Input<HTMLInputElement>>(\n        ref_,\n        instance => instance.inputElement\n      ),\n      [ref_]\n    );\n\n    const scope = css.resolve`\n      .text-field {\n        display: flex;\n        flex-direction: column;\n        ${color ? \"--mdc-theme-primary: \" + color + \";\" : \"\"}\n        ${color ? \"--mdc-theme-secondary: \" + color + \";\" : \"\"}\n      }\n      .text-field :global(.mdc-floating-label--float-above) {\n        color: ${color}!important;\n      }\n      .text-field :global(.mdc-text-field__input),\n      .text-field :global(.mdc-floating-label),\n      .text-field :global(.mdc-text-field-helper-text) {\n        font-weight: 500;\n        font-family: ${theme.typography.fontFamily.brand};\n      }\n    `;\n\n    return (\n      <div className={cn(\"text-field\", className, scope.className)}>\n        {externalLabelContents ? (\n          <ExternalLabel\n            id={id}\n            required={required}\n            dense={!large}\n            color={color}\n          >\n            {externalLabelContents}\n          </ExternalLabel>\n        ) : null}\n        <MDCTextField {...props}>\n          <Input\n            inputType={textarea ? \"textarea\" : \"input\"}\n            isValid={!error}\n            id={id}\n            required={required}\n            ref={ref}\n            {...rest}\n          />\n        </MDCTextField>\n        {scope.styles}\n      </div>\n    );\n  }\n);\n\ninterface ExternalLabelProps {\n  id?: string;\n  dense?: boolean;\n  required?: boolean;\n  color?: string;\n  children?: React.ReactNode;\n}\n\nfunction ExternalLabel({\n  id,\n  dense,\n  required,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  color,\n  children,\n}: ExternalLabelProps) {\n  const theme = useTheme();\n\n  const scope = css.resolve`\n    .text-field-label {\n      font-family: ${theme.typography.fontFamily.brand};\n      font-weight: 500;\n    }\n  `;\n\n  return (\n    <label\n      className={cn(\n        \"text-field-label\",\n        {\n          \"text-field-label--dense\": dense,\n        },\n        scope.className\n      )}\n      htmlFor={id}\n    >\n      {children}\n      {required ? \"*\" : \"\"}\n      <style jsx>{`\n        .text-field-label {\n          font-size: 0.875rem;\n          font-weight: 500;\n          margin: 0.5rem 0;\n          display: inline-block;\n          font-weight: 400;\n          letter-spacing: 0.00937em;\n          color: rgba(0, 0, 0, 0.6);\n          text-align: left;\n          line-height: 1rem;\n        }\n\n        .text-field-label--dense {\n          font-size: 0.75rem;\n        }\n      `}</style>\n      {scope.styles}\n    </label>\n  );\n}\n\nexport default TextField;\n"]} */\n/*@ sourceURL=text-field.tsx */"), scope.styles);
+}
+ExternalLabel.propTypes = {
+  id: _pt.string,
+  dense: _pt.bool,
+  required: _pt.bool,
+  color: _pt.string,
+  children: _pt.node
+};
+var TextFieldComponent = TextField;
+
+export { TextFieldComponent as default };

package/donation/esm/donation/anchor.js

@@ -0,0 +1 @@
+export { default as Anchor } from '../components/anchor/anchor.js';

package/donation/esm/donation/button.js

@@ -0,0 +1 @@
+export { default as Button } from '../components/button/button.js';

package/donation/esm/donation/checkbox.js

@@ -0,0 +1 @@
+export { default as Checkbox } from '../components/checkbox/checkbox.js';

package/donation/esm/donation/combo-field.js

@@ -0,0 +1 @@
+export { default as ComboField } from '../components/combo-field/combo-field.js';

package/donation/esm/donation/elevation.js

@@ -0,0 +1 @@
+export { default as Elevation } from '../components/elevation/elevation.js';

package/donation/esm/donation/field-label.js

@@ -0,0 +1 @@
+export { default as FieldLabel } from '../components/field-helpers/field-label.js';

package/donation/esm/donation/flex.js

@@ -0,0 +1 @@
+export { default as Flex } from '../components/layout/flex.js';

package/donation/esm/donation/grid.js

@@ -0,0 +1 @@
+export { default as Grid } from '../components/layout/grid.js';

package/donation/esm/donation/icon.js

@@ -0,0 +1 @@
+export { default as Icon } from '../components/icon/icon.js';

package/donation/esm/donation/modal.js

@@ -0,0 +1 @@
+export { default as Modal } from '../components/modal/modal.js';

package/donation/esm/donation/navigation.js

@@ -0,0 +1 @@
+export { default as Navigation } from '../components/navigation/navigation.js';

package/donation/esm/donation/phone-number-input.js

@@ -0,0 +1 @@
+export { default as PhoneNumberInputV1 } from '../components/phone-number-input/phone-number-input-v1.js';

package/donation/esm/donation/radio.js

@@ -0,0 +1 @@
+export { default as Radio } from '../components/radio/radio.js';

package/donation/esm/donation/select.js

@@ -0,0 +1 @@
+export { default as Select } from '../components/select/select.js';

package/donation/esm/donation/single-date-picker.js

@@ -0,0 +1 @@
+export { default as SingleDatePicker } from '../components/date-picker/single-date-picker.js';

package/donation/esm/donation/stack.js

@@ -0,0 +1 @@
+export { default as Stack } from '../components/layout/stack.js';

package/donation/esm/donation/text-field.js

@@ -0,0 +1,5 @@
+import TextFieldComponent from '../components/text-field/text-field.js';
+
+const TextField = TextFieldComponent;
+
+export { TextField };

package/donation/esm/donation/text.js

@@ -0,0 +1 @@
+export { default as Text } from '../components/text/text.js';

package/donation/esm/theme/colors.js

@@ -0,0 +1,7 @@
+const WHITE = "#ffffff";
+const BRAND_DARK_GREY = "#3e3e3f";
+const INACTIVE_GREY = "#9e9e9e";
+const BACKGROUND_GREY = "#efefef";
+const ON_BACKGROUND_GREY_GREY = "#dbdbdb";
+
+export { BACKGROUND_GREY, BRAND_DARK_GREY, INACTIVE_GREY, ON_BACKGROUND_GREY_GREY, WHITE };

package/donation/esm/theme/mycause-theme.js

@@ -0,0 +1,40 @@
+const WHITE = "#ffffff";
+const BRAND_GREEN_ACCESSIBLE = "#358b76";
+const BRAND_GREEN_ACCENT = "#42ccae";
+const BRAND_CORAL = "#f05c6a";
+const BRAND_DARK_GREY = "#3e3e3f";
+const BG_PARTNER = "linear-gradient(90deg, #e96a6d 0%, #e17221 100%), rgba(0, 0, 0, 0.2)";
+const MyCauseTheme = {
+  typography: {
+    fontFamily: {
+      brand: "'Montserrat', sans-serif",
+      default: "'Open Sans', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'",
+      alternate: "'Montserrat Alternates', Montserrat, sans-serif"
+    }
+  },
+  color: {
+    foreground: {
+      neutral: BRAND_DARK_GREY,
+      primary: BRAND_GREEN_ACCESSIBLE,
+      accent: BRAND_GREEN_ACCENT,
+      secondary: BRAND_CORAL,
+      muted: "rgba(0, 0, 0, 0.6)",
+      inactive: "rgba(0, 0, 0, 0.37)",
+      partner: BG_PARTNER,
+      coral: "rgb(225, 114, 33)"
+    },
+    background: {
+      neutral: WHITE,
+      primary: WHITE,
+      accent: WHITE,
+      secondary: WHITE,
+      muted: WHITE,
+      inactive: "rgba(0, 0, 0, 0.12)",
+      partner: WHITE,
+      coral: WHITE
+    }
+  }
+};
+var MyCauseTheme$1 = MyCauseTheme;
+
+export { MyCauseTheme$1 as default };

package/donation/esm/theme/theme.js

@@ -0,0 +1,59 @@
+import _pt from 'prop-types';
+import 'styled-jsx/style';
+import { useContext, createContext } from 'react';
+import MyCauseTheme from './mycause-theme.js';
+export { default as MyCauseTheme } from './mycause-theme.js';
+
+const ThemeContext = /*#__PURE__*/createContext(MyCauseTheme);
+({
+  value: _pt.shape({
+    typography: _pt.shape({
+      fontFamily: _pt.shape({
+        brand: _pt.string.isRequired,
+        default: _pt.string.isRequired,
+        alternate: _pt.string.isRequired
+      }).isRequired
+    }).isRequired,
+    color: _pt.shape({
+      foreground: _pt.shape({
+        neutral: _pt.string.isRequired,
+        primary: _pt.string.isRequired,
+        accent: _pt.string.isRequired,
+        secondary: _pt.string.isRequired,
+        muted: _pt.string.isRequired,
+        inactive: _pt.string.isRequired,
+        partner: _pt.string.isRequired,
+        coral: _pt.string.isRequired
+      }).isRequired,
+      background: _pt.shape({
+        neutral: _pt.string.isRequired,
+        primary: _pt.string.isRequired,
+        accent: _pt.string.isRequired,
+        secondary: _pt.string.isRequired,
+        muted: _pt.string.isRequired,
+        inactive: _pt.string.isRequired,
+        partner: _pt.string.isRequired,
+        coral: _pt.string.isRequired
+      }).isRequired
+    }).isRequired
+  }).isRequired,
+  children: _pt.node
+});
+function useTheme() {
+  return useContext(ThemeContext);
+}
+function getColorToken(theme, kind, color) {
+  let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  if (options.invert) {
+    kind = kind === "foreground" ? "background" : "foreground";
+  }
+  if (typeof color === "object") {
+    return color[kind];
+  } else if (color in theme.color.foreground) {
+    return theme.color[kind][color];
+  } else {
+    return color;
+  }
+}
+
+export { ThemeContext, getColorToken, useTheme };

package/donation/esm/utils/browser.js

@@ -0,0 +1,11 @@
+// Checks whether the current browser is Internet Explorer
+function isInternetExplorer() {
+  if (typeof window !== "undefined") {
+    const ua = window.navigator.userAgent;
+    const re = /MSIE|Trident/;
+    return !!ua.match(re);
+  }
+  return false;
+}
+
+export { isInternetExplorer };

package/donation/esm/utils/flags.js

@@ -0,0 +1,20 @@
+/* takes an object with flags and returns the key of the first flag set to true */
+function flags(flags, def) {
+  let result = undefined;
+  for (const [flag, value] of Object.entries(flags)) {
+    if (value) {
+      if (process.env.NODE_ENV !== "production") {
+        if (result) {
+          console.warn(`[Warning] multiple clashing flags specified ${result}, ${flag}. You must only pass one.`);
+        }
+      }
+      result = flag;
+      if (process.env.NODE_ENV === "production") {
+        break;
+      }
+    }
+  }
+  return result || def;
+}
+
+export { flags };