@edvisor/product-language 0.2.0 → 0.3.1

package/src/lib/components/input-field/input-field.tsx

@@ -1,126 +0,0 @@
-import styled from 'styled-components'
-import { InputHTMLAttributes } from 'react'
-
-import { Borders, Focused, Margin, Padding, Surface, Typography, _Typography } from '@foundations'
-import { getSlot, Slot, is, forwardRef, If } from '@helpers'
-import { Flex, SpaceBetween } from '../layout'
-
-import { LabeledInput } from './components'
-import { Label1, Label2 } from 'components/typography'
-
-const FancyBorder = styled(SpaceBetween)<{ invalid?: boolean }>`
-  background: ${({ invalid }) => is(invalid) ? Surface.Critical.Subdued : Surface.Default.Default };
-  border: 1px solid ${({ invalid }) => is(invalid) ? Borders.Critical.Default : Borders.Default.Default  };
-  border-radius: 6px;
-  box-sizing: border-box;
-  margin-bottom: ${Margin.xxs};
-  padding-left: ${Padding.s};
-
-  user-select: none;
-
-  :focus, :focus-within, :active {
-    border: ${({ invalid }) => is(invalid) 
-      ? `1px solid ${Borders.Critical.Default}` 
-      : `2px solid ${Focused.Default}` 
-    };
-  }
-`
-
-const InputLayout = styled(Flex)`
-  width: 100%;
-`
-
-export const HTMLInput = styled.input`
-  all: unset;
-
-  padding: ${Padding.none} ${Padding.none} ${Padding.xs} ${Padding.none};
-
-  width: 100%;
-
-  ::-webkit-inner-spin-button {
-    -webkit-appearance: none;
-    margin: ${Margin.none};
-  }
-
-  ${Typography.Body}
-
-  ::placeholder {
-    ${_Typography.LightText}
-  }
-`
-
-const PrefixFrame = styled(Label1)`
-  margin-right: ${Margin.xs};
-`
-
-const SuffixFrame = styled(Label1)`
-  margin-right: ${Margin.xs};
-`
-
-class IconSlot extends Slot {}
-class ControlsSlot extends Slot {}
-
-export type InputFieldSlots = {
-  Icon: typeof IconSlot,
-  Controls: typeof ControlsSlot,
-  Label: typeof LabeledInput,
-}
-
-interface IInputFieldProps extends InputHTMLAttributes<HTMLInputElement> {
-  invalid?: boolean
-  prefix?: string
-  suffix?: string
-  label?: string
-}
-
-const InputFrame = styled.label`
-  width: 100%;
-  padding: ${Padding.xs} ${Padding.none} ${Padding.none} ${Padding.none};
-  flex-direction: column;
-  display: flex;
-`
-
-const ControlsFrame = Flex
-
-const Label = styled(Label2)`
-  margin-bottom: ${Margin.xxs};
-`
-
-export const InputField = forwardRef<
-  HTMLInputElement,
-  IInputFieldProps,
-  InputFieldSlots
->((props: IInputFieldProps, ref) => {
-  const { children, prefix, suffix, label, className, ...inputProps } = props
-  const icon = getSlot(IconSlot, children)
-  const controls = getSlot(ControlsSlot, children)
-  const required = is(props.required) ? '*' : ''
-
-  return (
-    <FancyBorder invalid={props.invalid} className={className}>
-      <InputFrame>
-        <If is={label}>
-          <Label subdued>
-            {label}
-            {required}
-          </Label>
-        </If>
-        <InputLayout>
-          {icon}
-          <If is={prefix}>
-            <PrefixFrame subdued>{prefix}</PrefixFrame>
-          </If>
-          <HTMLInput ref={ref} {...inputProps} />
-          <If is={suffix}>
-            <SuffixFrame subdued>{suffix}</SuffixFrame>
-          </If>
-        </InputLayout>
-      </InputFrame>
-      <ControlsFrame center>{controls}</ControlsFrame>
-    </FancyBorder>
-  )
-})
-
-InputField.Icon = IconSlot
-InputField.Controls = ControlsSlot
-InputField.Label = LabeledInput

package/src/lib/components/input-field/input-number.tsx

@@ -1,41 +0,0 @@
-import { FC, isNil } from '@helpers'
-import { InputField, InputFieldSlots } from './input-field'
-import { Stepper } from './components'
-
-interface IInputNumberProps {
-  value?: number
-  onChange: (change?: number) => void
-
-  label?: string
-  placeholder?: string
-  invalid?: boolean
-  prefix?: string
-  suffix?: string
-  required?: boolean
-}
-
-type IInputNumberSlots = InputFieldSlots & {
-  Stepper: typeof Stepper
-}
-
-export const InputNumber: FC<IInputNumberProps, IInputNumberSlots> = (props) => {
-  const { onChange, value, ...inputFieldProps } = props
-
-  return (
-    <InputField 
-      type='number'
-      value={isNil(value) || isNaN(value) ? '' : value}
-      onChange={(e) => {
-        const next = e.target.value === '' ? undefined : parseFloat(e.target.value)
-
-        onChange(next)
-      }}
-      {...inputFieldProps}
-    />
-  )
-}
-
-InputNumber.Icon = InputField.Icon
-InputNumber.Controls = InputField.Controls
-InputNumber.Label = InputField.Label
-InputNumber.Stepper = Stepper

package/src/lib/components/input-field/input-text.tsx

@@ -1,30 +0,0 @@
-import { FC } from '@helpers'
-import { InputField, InputFieldSlots } from './input-field'
-
-interface IInputTextProps {
-  value: string
-  onChange: (change: string) => void
-
-  label?: string
-  invalid?: boolean
-  placeholder?: string
-  prefix?: string
-  suffix?: string
-  required?: boolean
-}
-
-export const InputText: FC<IInputTextProps, InputFieldSlots> = (props) => {
-  const { onChange, ...inputFieldProps } = props
-
-  return (
-    <InputField 
-      type='text'
-      onChange={(e) => onChange(e.target.value)}
-      {...inputFieldProps}
-    />
-  )
-}
-
-InputText.Icon = InputField.Icon
-InputText.Controls = InputField.Controls
-InputText.Label = InputField.Label

package/src/lib/components/input-field/storybook/components.tsx

@@ -1,334 +0,0 @@
-import styled from 'styled-components'
-import { useForm } from 'react-hook-form'
-
-import { Icons, Margin } from '@foundations'
-import { SpaceBetween } from 'components/layout'
-import { InputField } from '../input-field'
-
-import { Playground } from 'storybook-addon-jarle-monaco'
-import { InputNumber } from '../input-number'
-import { InputText } from '../input-text'
-
-/** @TODO placeholder Icon until the icons are done */
-export const Icon = styled.div`
-  height: 16px;
-  width: 16px;
-  border: 2px solid ${Icons.Default};
-  border-radius: 50%;
-  margin-right: ${Margin.xs};
-`
-
-export const PlainHTMLFormExample = () => (
-  <Playground
-    code={`
-/* Edit this code sample! */
-const [invalid, setInvalid] = useState(false);
-
-<form onSubmit={(e) => e.preventDefault()}>
-  <label htmlFor="country_code">Country code*</label>
-  {/* try replacing this element with an <input /> */}
-  <InputField 
-    // try setting the prefix, suffix, and invalid props
-    type="text" 
-    placeholder="Enter a country code..."
-    id="country_code"
-    name="country_code"
-    pattern="[A-Za-z]{3}"
-    onInvalid={setInvalid}
-    invalid={invalid}
-    onChange={() => setInvalid(false)}
-    title="Three letter country code"
-    required
-  />
-  <input type="submit"/>
-</form>  
-    `}
-    providerProps={{
-      renderAsComponent: true,
-      scope: {
-        InputField,
-      },
-    }}
-  />
-)
-
-export const InnerLabelExample = () => (
-  <Playground
-    code={`
-<InputField 
-  type="text" 
-  label="Country Code"
-  placeholder="Enter a country code..."
-/>
-    `}
-    providerProps={{
-      renderAsComponent: true,
-      scope: {
-        InputField,
-      },
-    }}
-  />
-)
-
-export const ReactFormHookExample = () => (
-  <Playground
-    code={`
-const { register, formState: { errors }, handleSubmit } = useForm();
-const onSubmit = data => alert(data);
-  
-<form onSubmit={handleSubmit(onSubmit)}>
-  <InputField 
-    label="First name"
-    invalid={errors.firstName}
-    required
-    {...register("firstName", { required: true, maxLength: 20 })} 
-  />
-  <InputField 
-    label="Last name"
-    invalid={errors.lastName}
-    {...register("lastName", { pattern: /^[A-Za-z]+$/i })} 
-  />
-  <InputField 
-    label="Age"
-    type="number" 
-    invalid={errors.age}
-    {...register("age", { min: 18, max: 99 })} 
-    />
-  <input type="submit" />
-</form>
-    `}
-    providerProps={{
-      renderAsComponent: true,
-      scope: {
-        InputField,
-        useForm,
-      },
-    }}
-  />
-)
-
-export const SimpleInputExample = () => (
-  <Playground
-    code={`
-const [state, setState] = useState({ 
-  firstName: '', 
-  lastName: '', 
-  age: 18 
-});
-
-const onChange = (change) => setState({
-  ...state,
-  ...change
-});
-  
-<>
-  <InputText 
-    label="First name"
-    value={state.firstName} 
-    onChange={(firstName) => onChange({ firstName })} 
-  />
-  <InputText 
-    label="Last name"
-    value={state.lastName} 
-    onChange={(lastName) => onChange({ lastName })} 
-  />
-  <InputNumber 
-    label="Age"
-    value={state.age} 
-    onChange={(age) => onChange({ age })} 
-    required
-  />
-</>
-    `}
-    providerProps={{
-      renderAsComponent: true,
-      scope: {
-        InputNumber,
-        InputText,
-      },
-    }}
-  />
-)
-
-export const IconExample = () => (
-  <Playground
-    code={`
-<InputField 
-  label="Search"
-  type="text" 
-  prefix="🍺"
->
-  <InputField.Icon>
-    <Icon title="Icons render before the input" />
-  </InputField.Icon>
-</InputField>
-    `}
-    providerProps={{
-      renderAsComponent: true,
-      scope: {
-        InputField,
-        Icon,
-      },
-    }}
-  />
-)
-
-export const ControlsExample = () => (
-  <Playground
-    code={`
-const [likes, setLikes] = useState(0);
-
-const onLike = () => setLikes(likes + 1);
-const onDislike = () => setLikes(Math.max(likes - 1, 0));
-
-<InputField 
-  label="Do you like this storybook?"
-  value={likes}
-  onChange={() => undefined}
-  type="number" 
-  suffix="🍺"
->
-  <InputField.Controls>
-    <SpaceBetween>
-      <div onClick={onLike}>️👍</div>
-      <div>/</div>
-      <div onClick={onDislike}>👎️</div>
-    </SpaceBetween>
-  </InputField.Controls>
-</InputField>
-    `}
-    providerProps={{
-      renderAsComponent: true,
-      scope: {
-        InputField,
-        Icon,
-        styled,
-        SpaceBetween,
-      },
-    }}
-  />
-)
-
-export const OuterLabelExample = () => (
-  <Playground
-    code={`
-const [value, setValue] = useState('');
-const [errors, setErrors] = useState([]);
-
-const handleChange = (change: string) => {
-  const errors = [];
-
-  if (!change) {
-    errors.push({ message: 'This field is required' });
-  }
-
-  if (!change.match(/[A-Za-z]{3}/)) {
-    errors.push({ message: 'Input was not a 3 letter country code' });
-  }
-
-  setValue(change);
-  setErrors(errors);
-}
-
-<InputText.Label
-  label="Country Code"
-  helpText="Please enter a 3 letter country code"
-  errors={errors}
->
-  <InputText 
-    value={value}
-    invalid={errors.length > 0}
-    placeholder="e.g. AUD"
-    onChange={handleChange}
-  />
-</InputText.Label>
-    `}
-    providerProps={{
-      renderAsComponent: true,
-      scope: {
-        InputText,
-        Icon,
-      },
-    }}
-  />
-)
-
-export const StepperExample = () => (
-  <Playground
-    code={`
-const [age, setAge] = useState(0);
-const onUp = () => setAge(Math.min(age + 1, 99));
-const onDown = () => setAge(Math.max(age - 1, 0));
-const errors = []
-
-if (0 > age || age > 100) {
-  errors.push({ message: 'Please choose an age between 0 and 99' })
-}
-
-<form onSubmit={(e) => e.preventDefault()}>
-  <InputNumber.Label 
-    helpText='Age should be a number between 0 and 99'
-    errors={errors}
-  >
-    <InputNumber 
-      label='Age' 
-      onChange={setAge}
-      value={age}
-      invalid={errors.length > 0}
-      placeholder="Enter your age..."
-    >
-      <InputNumber.Controls>
-        <InputNumber.Stepper onUpClick={onUp} onDownClick={onDown} />
-      </InputNumber.Controls>
-    </InputNumber>
-  </InputNumber.Label>
-  <input type="submit"/>
-</form>  
-    `}
-    providerProps={{
-      renderAsComponent: true,
-      scope: {
-        InputNumber,
-        styled,
-      },
-    }}
-  />
-)
-
-export const AllDressedExample = () => (
-  <Playground
-    code={`
-<InputField.Label 
-  label='Price'
-  helpText='Enter a price in AUD'
-  errors={[{ message: 'Too many UI decorations!' }]}
->
-  <InputField 
-    type="number" 
-    label='Price' 
-    // prefix and suffix render immediately 
-    // before and after the input field
-    prefix="$"
-    suffix="AUD"
-    step={0.01}
-    min={0.00}
-    placeholder="Enter an amount..."
-  >
-    <InputField.Icon>
-      <Icon title="Icons render before the input" />
-    </InputField.Icon>
-    <InputField.Controls>
-      <Icon title="Controls render after the input" />
-    </InputField.Controls>
-  </InputField>
-</InputField.Label>
-    `}
-    providerProps={{
-      renderAsComponent: true,
-      scope: {
-        InputField,
-        Icon,
-      },
-    }}
-  />
-)

package/src/lib/components/input-field/storybook/input-field.stories.mdx

@@ -1,113 +0,0 @@
-import { Canvas, Meta, Story } from '@storybook/addon-docs';
-import { Card, SpaceBetween } from '@components'
-import { Playground } from 'storybook-addon-jarle-monaco'
-import { InputField } from '../input-field'
-import { PlainHTMLFormExample, ReactFormHookExample, SimpleInputExample, AllDressedExample, OuterLabelExample, IconExample, ControlsExample, StepperExample, InnerLabelExample } from './components'
-
-<Meta title="Components/input-field"/>
-
-# Input Field
-
-An Input Field is a component that users can type into. It has a range of options and supports several text formats including numbers.
-
-### Table of Contents
-1. [Familiar HTML Input API](#familiar-html-input-api)
-2. [Slots and sub-components](#slots-and-sub-components)
-
-<div id='familiar-html-input-api'/>
-
-## Familiar HTML input API
-
-The input field is a drop-in replacement for the common HTML input element. It accepts all of the usual props for such an element. As you can see in the code sample below, you can simple use InputField the same way as you could a normal HTML input field. It has a few additional properties which can be used to style the component.
-
-The available optional properties are as follows, try them out in the editable code sample below!
-
-| Prop       | Type      | Description                                                              |
-| ---------- | --------- | ------------------------------------------------------------------------ |
-| `prefix?`  | `string`  | add a small text before the input                                        |
-| `suffix?`  | `string`  | add a small text after the input                                         |
-| `label?`   | `string`  | a label to be displayed inside the input element, above the input itself |
-| `invalid?` | `boolean` | indicate that the input is invalid                                       |
-
-<PlainHTMLFormExample />
-
-Notice that in this example (and only this example) we are using HTML's native "constraint validation API" to detect and display errors. Doing this involves watching the `onInvalid` event, and setting the invalid flag on the input if it fires.
-
-### `props.label`
-
-Passing a label will add a name inside the input field, above where the input will appear. This is a fancy new way people like to do inputs, and we might be adopting this style, so for now the examples will mostly all have inner labels.
-
-<InnerLabelExample />
-
-### Managing State
-
-Because the input field can be used just like a regular HTML input, you can use common state-management libraries. For example, we used react-form-hook to implement the following code sample. Try it out!
-
-<ReactFormHookExample />
-
-
-### Simple Input API
-
-The input-field module also exposes a set of components with more stream-lined APIs for implementing common UIs. These can be used instead of the base `InputField`` when you don't need all the bells and whistles of a raw HTML input, or when you aren't in the context of a form and just want to manage state with useState. The main motivation for providing these is to give the user a simple "string goes in, string comes out" API, so that they do not need to deal with HTML events.
-
-These simple components obey the following API. In addition they have all the same optional properties described above:
-
-| Prop        | Type                  | Description                                                                       |
-| ----------- | --------------------- | --------------------------------------------------------------------------------- |
-| `value`     | `T`                   | The value of the controlled input                                                 |
-| `onChange`  | `(change: T) => void` | Called when the value changes                                                     |
-| `required?` | `boolean`             | Passed to the inner HTML element, renders an * (asterisk) next to the inner-label |
-
-<SimpleInputExample />
-
-<div id='slots-and-sub-components'/>
-
-## Slots and sub-components
-
-Using a combination of slots, sub-components, and the optional properties described above, it is possible to customize the components quite a bit. The available components include:
-
-| Slot                  | Type    | Description                                                                                       |
-| --------------------- | ------- | ------------------------------------------------------------------------------------------------- |
-| `InputField.Icon`     | Slot    | Places the children before the input, children should be small                                    |
-| `InputField.Controls` | Slot    | Places the children after the input, children should be small                                     |
-| `InputField.Label`    | Wrapper | A wrapper for the input field that renders labels, help text, and error messages around the input |
-
-### `InputField.Icon`
-
-The `Icon` slot provides a convenient way to add a small icon (typically 20 x 20 pixel) to the left of the input, before the prefix. In the examples below we are using a grey circle as our example "icon" because the icons were not ready at the time of this writing, and the prefix is set to a 🍺.
-
-<IconExample />
-
-### `InputField.Controls`
-
-The `Controls` slot is used to add a small icon or other component to the right side of the input, after the suffix. This is useful for adding steppers to number inputs, or a little grey X that clears the input when clicked. You can supply anything you like, but the intention is for this element to be clickable. In this example, the suffix is set to a 🍺 and notice that it is lined up with the input and prefix on the left-side, _not_ the controls on the right-side.
-
-<ControlsExample />
-
-### `InputField.Label`
-
-The `Label` sub-component is used to wrap the `InputField` component. It provides the eponymous "label" for the wrapped input element, as an outer later. It is also used to provide additional label adjacent texts such as help text and error messages. Since we have begun to adopt an inner labelling system, this outer label will primarily be used to provide help text and errors. Since it is an HTML label element, you can click on any of these labels to focus the input.
-
-The Label's API is given below.
-
-| Prop        | Type                    | Description                                                      |
-| ----------- | ----------------------- | ---------------------------------------------------------------- |
-| `label?`    | `string`                | The primary label, title, or "name" of the wrapped input element |
-| `helpText?` | `string`                | A string of help text to be displayed below the input            |
-| `errors?`   | `{ message: string }[]` | An array of error messages to be displayed below the input.      |
-
-Also note that the example below uses `InputText.Label` rather than `InputField.Label`. All of the sub-components and slots available on the `InputField` are also available on the simple inputs, unless otherwise mentioned.
-
-<OuterLabelExample />
-
-### `InputNumber.Stepper`
-
-Not mentioned in the general API above, but worthy of note, the stepper is such a common control for number inputs that we have provided it as a sub-component of the `InputNumber` simple input. It can be dropped into any input, not only the `InputNumber`, as you can see in the example below.
-
-<StepperExample />
-
-### All Dressed
-
-Finally, just for fun, here is an example of an input with everything! Never actually do this, it's awful.
-
-<AllDressedExample />

package/src/lib/components/layout/flex.tsx

@@ -1,22 +0,0 @@
-import styled from 'styled-components'
-import { is } from '@helpers'
-
-export const Flex = styled.div<{ column?: boolean, center?: boolean }>`
-  display: flex;
-  ${({ center }) => is(center) ? 'align-items: center;' : '' }
-  flex-direction: ${({ column }) => is(column) ? 'column' : 'row'}
-`
-
-export const SpaceBetween = styled(Flex)`
-  justify-content: space-between;
-`
-
-export const SpaceAround = styled(Flex)`
-  justify-content: space-around;
-`
-
-export const Center = styled(Flex)`
-  align-items: center;
-  justify-content: space-around;
-`
-

package/src/lib/components/layout/grid-layout.tsx

@@ -1,40 +0,0 @@
-import styled from 'styled-components'
-import { isDefined } from '@helpers'
-
-interface IGridLayoutGeneratorProps {
-  columns?: number
-  rows?: number
-  columnGutter?: number
-  rowGutter?: number
-}
-
-const DEFAULT: IGridLayoutGeneratorProps = {
-  columns: 12,
-  columnGutter: 24,
-  rowGutter: 24,
-}
-
-export function gridLayoutGenerator (props: IGridLayoutGeneratorProps = {}) {
-  const options = {
-    ...DEFAULT,
-    ...props,
-  }
-
-  const Grid = styled.div`
-    display: grid;
-    grid-template-columns: repeat(${options.columns}, 1fr);
-    ${isDefined(options.rows) 
-      ? `grid-template-rows: repeat(${options.rows}, 1fr);` 
-      : ''}
-    grid-column-gap: ${options.columnGutter}px;
-    grid-row-gap: ${options.rowGutter}px;
-  `
-
-  const Cell = styled.div`
-  `
-
-  return {
-    Grid,
-    Cell,
-  }
-}