@bspk/ui 1.1.32 → 1.1.33

package/src/components/TextInput/TextInput.tsx

@@ -0,0 +1,145 @@
+import { SvgCancel } from '@bspk/icons/Cancel';
+import { ChangeEvent, HTMLInputAutoCompleteAttribute, HTMLInputTypeAttribute, ReactNode } from 'react';
+
+import { ElementProps, CommonProps, InvalidPropsLibrary, SetRef } from '-';
+import { useId } from '-/hooks/useId';
+
+import './text-input.scss';
+
+export const DEFAULT = {
+    size: 'medium',
+    value: '',
+    type: 'text' as Extract<HTMLInputTypeAttribute, 'number' | 'text'>,
+    autoComplete: 'off',
+} as const;
+
+export type TextInputProps = CommonProps<
+    'aria-label' | 'disabled' | 'id' | 'name' | 'readOnly' | 'required' | 'size' | 'value'
+> &
+    InvalidPropsLibrary & {
+        /**
+         * Callback when the value of the field changes.
+         *
+         * @required
+         */
+        onChange: (next: string, event?: ChangeEvent<HTMLInputElement>) => void;
+        /** The ref of the container. */
+        containerRef?: SetRef<HTMLDivElement>;
+        /** The ref of the input. */
+        inputRef?: SetRef<HTMLInputElement>;
+        /**
+         * The trailing element to display in the field.
+         *
+         * @exampleType string
+         */
+        trailing?: ReactNode;
+        /**
+         * The leading element to display in the field.
+         *
+         * @exampleType string
+         */
+        leading?: ReactNode;
+        /** The placeholder of the field. */
+        placeholder?: string;
+        /**
+         * The type of the input.
+         *
+         * @default text
+         */
+        type?: Extract<HTMLInputTypeAttribute, 'number' | 'text'>;
+        /**
+         * Specifies if user agent has any permission to provide automated assistance in filling out form field values
+         *
+         * @default off
+         */
+        autoComplete?: HTMLInputAutoCompleteAttribute;
+    };
+
+/**
+ * A text input that allows users to enter text, numbers or symbols in a singular line. This is the base element and is
+ * not intended to be used directly. Use the TextField component.
+ *
+ * @example
+ *     import { useState } from 'react';
+ *     import { TextInput } from '@bspk/ui/TextInput';
+ *
+ *     export function Example() {
+ *         const [value, setValue] = useState<string>('');
+ *
+ *         return <TextInput aria-label="Example aria-label" name="Example name" onChange={setValue} value={value} />;
+ *     }
+ *
+ * @element
+ *
+ * @name TextInput
+ * @phase DesignReview
+ */
+function TextInput({
+    invalid: invalidProp,
+    onChange,
+    size = DEFAULT.size,
+    value = DEFAULT.value,
+    name,
+    'aria-label': ariaLabel,
+    inputRef,
+    required,
+    placeholder,
+    id: idProp,
+    leading,
+    trailing,
+    type = DEFAULT.type,
+    readOnly,
+    disabled,
+    autoComplete = DEFAULT.autoComplete,
+    containerRef,
+    errorMessage,
+    ...otherProps
+}: ElementProps<TextInputProps, 'div'>) {
+    const id = useId(idProp);
+
+    const invalid = !readOnly && !disabled && invalidProp;
+
+    return (
+        <div
+            data-bspk="text-input"
+            data-disabled={disabled || undefined}
+            data-empty={!value.toString().length || undefined}
+            data-invalid={invalid || undefined}
+            data-readonly={readOnly || undefined}
+            data-required={required || undefined}
+            data-size={size}
+            ref={containerRef}
+            {...otherProps}
+        >
+            {leading && <span data-leading>{leading}</span>}
+            <input
+                aria-errormessage={errorMessage || undefined}
+                aria-invalid={invalid || undefined}
+                aria-label={ariaLabel}
+                autoComplete={autoComplete}
+                disabled={disabled || undefined}
+                id={id}
+                name={name}
+                onChange={(event) => {
+                    onChange(event.target.value, event);
+                }}
+                placeholder={placeholder || ' '}
+                readOnly={readOnly || undefined}
+                ref={inputRef}
+                required={required || undefined}
+                type={type}
+                value={value || ''}
+            />
+            {trailing && <span data-trailing>{trailing}</span>}
+            <button aria-label="clear" data-clear onClick={() => onChange('')}>
+                <SvgCancel />
+            </button>
+        </div>
+    );
+}
+
+TextInput.bspkName = 'TextInput';
+
+export { TextInput };
+
+/** Copyright 2025 Anywhere Real Estate - CC BY 4.0 */

package/src/components/TextInput/TextInputExample.tsx

@@ -0,0 +1,35 @@
+import { ComponentExample } from '-/utils/demo';
+
+import { TextInputProps } from '.';
+
+export const TextInputExample: ComponentExample<TextInputProps> = {
+    presets: [
+        {
+            label: 'Currency',
+            propState: {
+                type: 'number',
+                leading: '$',
+                trailing: undefined,
+                placeholder: 'currency',
+            },
+        },
+        {
+            label: 'Percent',
+            propState: {
+                type: 'number',
+                leading: undefined,
+                trailing: '%',
+                placeholder: 'percent',
+            },
+        },
+        {
+            label: 'Dimension',
+            propState: {
+                type: 'number',
+                leading: undefined,
+                placeholder: 'dimensions',
+                trailing: 'ft',
+            },
+        },
+    ],
+};

package/src/components/TextInput/index.tsx

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

package/src/components/TextInput/text-input.scss

@@ -0,0 +1,146 @@
+[data-bspk='text-input'] {
+    --border-color: var(--stroke-neutral-base);
+
+    display: flex;
+    flex-flow: row nowrap;
+    background-color: var(--surface-neutral-t1-base);
+    border: solid 1px var(--border-color);
+    height: var(--field-height);
+    border-radius: var(--radius-small);
+    padding: 0 0 0 var(--field-padding);
+    gap: var(--spacing-sizing-01);
+    width: 100%;
+
+    & > * {
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        height: var(--field-height);
+        font: var(--field-font);
+        color: var(--foreground-neutral-on-surface);
+        min-width: 0;
+    }
+
+    &:hover:not(:focus-within) {
+        background:
+            linear-gradient(var(--interactions-hover-opacity), var(--interactions-hover-opacity)),
+            linear-gradient(var(--surface-neutral-t1-base), var(--surface-neutral-t1-base));
+    }
+
+    &:active:not(:focus-within) {
+        background:
+            linear-gradient(var(--interactions-press-opacity), var(--interactions-press-opacity)),
+            linear-gradient(var(--surface-neutral-t1-base), var(--surface-neutral-t1-base));
+    }
+
+    &[data-readonly] {
+        --border-color: var(--stroke-neutral-disabled-light);
+
+        background:
+            linear-gradient(var(--interactions-disabled-opacity), var(--interactions-disabled-opacity)),
+            linear-gradient(var(--surface-neutral-t1-base), var(--surface-neutral-t1-base));
+    }
+
+    &[data-disabled],
+    &:has(input[disabled]) {
+        --border-color: var(--stroke-neutral-disabled-light);
+
+        background:
+            linear-gradient(var(--interactions-disabled-opacity), var(--interactions-disabled-opacity)),
+            linear-gradient(var(--surface-neutral-t1-base), var(--surface-neutral-t1-base));
+
+        & > * {
+            color: var(--foreground-neutral-disabled-on-surface);
+        }
+    }
+
+    &[data-invalid] {
+        --border-color: var(--status-error);
+    }
+
+    &[data-size='small'] {
+        --field-padding: var(--spacing-sizing-02);
+        --field-height: var(--spacing-sizing-08);
+        --field-font: var(--body-small);
+        --field-icon-width: var(--spacing-sizing-04);
+        --field-clear-width: var(--spacing-sizing-05);
+    }
+
+    &[data-size='medium'] {
+        --field-padding: var(--spacing-sizing-03);
+        --field-height: var(--spacing-sizing-10);
+        --field-font: var(--body-base);
+        --field-icon-width: var(--spacing-sizing-05);
+        --field-clear-width: var(--spacing-sizing-05);
+    }
+
+    &[data-size='large'] {
+        --field-padding: var(--spacing-sizing-03);
+        --field-height: var(--spacing-sizing-12);
+        --field-font: var(--body-large);
+        --field-icon-width: var(--spacing-sizing-06);
+        --field-clear-width: var(--spacing-sizing-06);
+    }
+
+    [data-leading],
+    [data-trailing] {
+        svg {
+            width: var(--field-icon-width);
+        }
+    }
+
+    label {
+        font: var(--labels-small);
+        color: var(--foreground-neutral-on-surface-variant-01);
+    }
+
+    input {
+        flex: 1;
+        background-color: transparent !important;
+        border: none;
+        outline: none;
+        padding: 0;
+        pointer-events: all;
+        text-overflow: ellipsis;
+
+        &[type='number']::-webkit-inner-spin-button,
+        &[type='number']::-webkit-outer-spin-button {
+            display: none;
+        }
+    }
+
+    button[data-clear] {
+        display: flex;
+        border: none;
+        background: none;
+        padding: 0;
+        cursor: pointer;
+        pointer-events: all;
+        margin-left: var(--spacing-sizing-02);
+        padding-right: var(--field-padding);
+
+        svg {
+            pointer-events: none;
+            width: var(--field-clear-width);
+        }
+    }
+
+    &:not(:focus-within),
+    &[data-empty],
+    &[data-readonly],
+    &[data-disabled] {
+        padding-right: var(--field-padding);
+
+        button[data-clear] {
+            display: none;
+        }
+    }
+
+    &:focus-within {
+        --border-color: var(--stroke-neutral-focus);
+
+        outline: 1px solid var(--stroke-neutral-focus);
+    }
+}
+
+/** Copyright 2025 Anywhere Real Estate - CC BY 4.0 */

package/src/components/Textarea/Textarea.tsx

@@ -0,0 +1,164 @@
+import { ChangeEvent, useRef } from 'react';
+
+import { CommonProps, InvalidPropsLibrary, SetRef } from '-';
+import { useId } from '-/hooks/useId';
+import { cssWithVars } from '-/utils/cwv';
+import './textarea.scss';
+
+const DEFAULT = {
+    minRows: 3,
+    maxRows: 10,
+    textSize: 'medium',
+} as const;
+
+export type TextareaProps = CommonProps<'aria-label' | 'disabled' | 'id' | 'readOnly' | 'required'> &
+    InvalidPropsLibrary & {
+        /**
+         * Callback when the value of the field changes.
+         *
+         * @type (next: String, Event) => void
+         * @required
+         */
+        onChange: (next: string, event?: ChangeEvent<HTMLTextAreaElement>) => void;
+        /**
+         * The text size of the field.
+         *
+         * @default medium
+         */
+        textSize?: 'large' | 'medium' | 'small';
+        /**
+         * The value of the field.
+         *
+         * @type multiline
+         */
+        value?: string;
+        /**
+         * The textarea control name of the field.
+         *
+         * @required
+         */
+        name: string;
+        /** The ref of the field. */
+        innerRef?: SetRef<HTMLTextAreaElement>;
+        /** The placeholder of the field. */
+        placeholder?: string;
+        /**
+         * The maximum number of characters that the field will accept.
+         *
+         * @minimum 1
+         */
+        maxLength?: number;
+        /**
+         * The minimum number of rows that the textarea will show.
+         *
+         * @default 3
+         * @minimum 3
+         * @maximum 10
+         */
+        minRows?: number;
+        /**
+         * The maximum number of rows that the textarea will show.
+         *
+         * When set the textarea will automatically adjust its height to fit the content up to this limit.
+         *
+         * @default 3
+         * @minimum 3
+         * @maximum 10
+         */
+        maxRows?: number;
+    };
+
+/**
+ * A component that allows users to input large amounts of text that could span multiple lines.
+ *
+ * This component gives you a textarea HTML element that automatically adjusts its height to match the length of the
+ * content within maximum and minimum rows. A character counter when a maxLength is set to show the number of characters
+ * remaining below the limit.
+ *
+ * @example
+ *     import { useState } from 'react';
+ *     import { Textarea } from '@bspk/ui/Textarea';
+ *
+ *     export function Example() {
+ *         const [value, setValue] = useState<string>('');
+ *
+ *         return <Textarea aria-label="Example aria-label" name="Example name" onChange={setValue} value={value} />;
+ *     }
+ *
+ * @element
+ *
+ * @name Textarea
+ * @phase DesignReview
+ */
+function Textarea({
+    invalid: invalidProp,
+    onChange,
+    textSize = DEFAULT.textSize,
+    value = '',
+    name,
+    'aria-label': ariaLabel,
+    innerRef,
+    placeholder,
+    id: idProp,
+    minRows: minRowsProp = DEFAULT.minRows,
+    maxRows: maxRowsProp = DEFAULT.maxRows,
+    errorMessage,
+    ...otherProps
+}: TextareaProps) {
+    const id = useId(idProp);
+    const invalid = !otherProps.readOnly && !otherProps.disabled && invalidProp;
+    // ensure minRows and maxRows are within bounds
+    const minRows = Math.min(DEFAULT.maxRows, Math.max(minRowsProp, DEFAULT.minRows));
+    const maxRows = Math.max(DEFAULT.minRows, Math.min(maxRowsProp, DEFAULT.maxRows));
+
+    const onInput = () => {
+        const target = textareaElement.current;
+        if (!target) return;
+        // we know the textarea was resized, so we don't want to auto-size it
+        if (target.style.height) return;
+        (target.nextSibling as HTMLElement).innerText = `${target.value}\n`;
+    };
+
+    const textareaElement = useRef<HTMLTextAreaElement | null>(null);
+
+    return (
+        <div
+            data-bspk="textarea"
+            data-size={textSize}
+            style={cssWithVars({
+                '--min-rows': minRows,
+                '--max-rows': maxRows,
+            })}
+        >
+            <textarea
+                {...otherProps}
+                aria-errormessage={errorMessage || undefined}
+                aria-invalid={invalid || undefined}
+                aria-label={ariaLabel}
+                id={id}
+                name={name}
+                onBlur={(event) => {
+                    const target = event.target as HTMLTextAreaElement;
+                    target.scrollTop = 0;
+                }}
+                onChange={(event) => onChange(event.target.value, event)}
+                onInput={onInput}
+                placeholder={placeholder}
+                ref={(node) => {
+                    innerRef?.(node);
+                    textareaElement.current = node;
+                    onInput();
+                }}
+                value={value}
+                wrap="hard"
+            />
+            <div aria-hidden data-replicated-value />
+        </div>
+    );
+}
+
+Textarea.bspkName = 'Textarea';
+
+export { Textarea };
+
+/** Copyright 2025 Anywhere Real Estate - CC BY 4.0 */

package/src/components/Textarea/TextareaExample.tsx

@@ -0,0 +1,5 @@
+import { ComponentExample } from '-/utils/demo';
+
+import { TextareaProps } from '.';
+
+export const TextareaExample: ComponentExample<TextareaProps> = {};

package/src/components/Textarea/index.tsx

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

package/src/components/Textarea/textarea.scss

@@ -0,0 +1,96 @@
+[data-bspk='textarea'] {
+    /*! 
+    --min-rows: is set via inline style 
+    --max-rows: is set via inline style
+    */
+
+    display: grid;
+    width: 100%;
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-small);
+    overflow: hidden;
+
+    --border-color: var(--stroke-neutral-base);
+
+    // &[data-size='medium']
+    --font: var(--body-base);
+    --line-height: 20px;
+    --padding: var(--spacing-sizing-03);
+
+    &[data-size='small'] {
+        --font: var(--body-small);
+        --line-height: 20px;
+        --padding: var(--spacing-sizing-02);
+    }
+
+    &[data-size='large'] {
+        --font: var(--body-large);
+        --line-height: 24px;
+        --padding: var(--spacing-sizing-03);
+    }
+
+    &:has(textarea:focus-within) {
+        --border-color: var(--stroke-neutral-focus);
+    }
+
+    &:has(textarea[aria-invalid]) {
+        --border-color: var(--status-error);
+    }
+
+    [data-replicated-value] {
+        white-space: pre-wrap;
+        visibility: hidden;
+        overflow-y: hidden;
+    }
+
+    textarea,
+    [data-replicated-value] {
+        width: 100%;
+        font: var(--font);
+        padding: var(--padding);
+        border: none;
+        background: transparent;
+        grid-area: 1 / 1 / 2 / 2;
+        min-height: calc((var(--line-height) * var(--min-rows)) + (var(--padding) * 2));
+        max-height: calc((var(--line-height) * var(--max-rows)) + (var(--padding) * 2));
+        max-width: 100%;
+    }
+
+    textarea {
+        text-wrap: break-word;
+
+        &::placeholder {
+            color: var(--foreground-neutral-on-surface-variant-03);
+        }
+
+        resize: none;
+        color: var(--foreground-neutral-on-surface);
+        background-color: var(--surface-neutral-t1-base);
+
+        &:focus-within {
+            outline: none;
+            color: var(--foreground-neutral-on-surface);
+        }
+
+        &:disabled {
+            pointer-events: none;
+            background: 
+    // multiple colors
+
+                linear-gradient(var(--interactions-disabled-opacity), var(--interactions-disabled-opacity)),
+                linear-gradient(var(--surface-neutral-t1-base), var(--surface-neutral-t1-base));
+            color: var(--foreground-neutral-disabled-on-surface);
+        }
+
+        &:read-only {
+            background: 
+    // multiple colors
+
+                linear-gradient(var(--interactions-disabled-opacity), var(--interactions-disabled-opacity)),
+                linear-gradient(var(--surface-neutral-t1-base), var(--surface-neutral-t1-base));
+            cursor: not-allowed;
+        }
+    }
+}
+
+/** Copyright 2025 Anywhere Real Estate - CC BY 4.0 */

package/src/components/TextareaField/TextareaField.tsx

@@ -0,0 +1,104 @@
+import { FormFieldProps, FormField } from '-/components/FormField';
+import { TextareaProps, Textarea } from '-/components/Textarea';
+import { Txt } from '-/components/Txt';
+import { tryIntParse } from '-/utils/tryIntPsrse';
+
+export type TextareaFieldProps = Pick<FormFieldProps, 'controlId' | 'helperText' | 'label'> &
+    TextareaProps & {
+        /**
+         * Whether the character count should be displayed.
+         *
+         * @default true
+         */
+        characterCount?: boolean;
+    };
+/**
+ * A component that allows users to input large amounts of text that could span multiple lines.
+ *
+ * This component takes properties from the FormField and Textarea components.
+ *
+ * @example
+ *     import { useState } from 'react';
+ *     import { TextareaField } from '@bspk/ui/TextareaField';
+ *
+ *     export function Example() {
+ *         const [value, setValue] = useState<string>();
+ *
+ *         return (
+ *             <TextareaField
+ *                 aria-label="Example aria-label"
+ *                 controlId="Example controlId"
+ *                 label="Example label"
+ *                 name="Example name"
+ *                 onChange={setValue}
+ *                 value={value}
+ *             />
+ *         );
+ *     }
+ *
+ * @name TextareaField
+ * @phase DesignReview
+ */
+function TextareaField({
+    label,
+    errorMessage: errorMessageProp,
+    helperText,
+    controlId: id,
+    onChange,
+    maxLength: maxLengthProp,
+    invalid,
+    readOnly,
+    disabled,
+    required,
+    characterCount = true,
+    ...textareaProps
+}: TextareaFieldProps) {
+    const maxLength = tryIntParse(maxLengthProp) || -1;
+    const errorMessage = (!readOnly && !disabled && errorMessageProp) || undefined;
+
+    if (typeof onChange !== 'function') return null;
+
+    return (
+        <FormField
+            controlId={id}
+            data-bspk="textarea-field"
+            errorMessage={errorMessage}
+            helperText={helperText}
+            invalid={invalid}
+            label={label}
+            labelTrailing={
+                characterCount && (
+                    <Txt
+                        style={{
+                            color: 'var(--foreground-neutral-on-surface-variant-02)',
+                        }}
+                        variant="body-small"
+                    >
+                        {`${textareaProps?.value?.length || 0}${maxLength > 0 ? `/${maxLength}` : ''}`}
+                    </Txt>
+                )
+            }
+            required={required}
+        >
+            {(fieldProps) => (
+                <Textarea
+                    {...textareaProps}
+                    {...fieldProps}
+                    aria-label={textareaProps['aria-label'] || label}
+                    id={id}
+                    invalid={invalid}
+                    onChange={(next, event) => {
+                        onChange(next, event);
+                    }}
+                    required={required}
+                />
+            )}
+        </FormField>
+    );
+}
+
+TextareaField.bspkName = 'TextareaField';
+
+export { TextareaField };
+
+/** Copyright 2025 Anywhere Real Estate - CC BY 4.0 */