@devtron-labs/devtron-fe-common-lib 0.0.52-beta-1 → 0.0.52-beta-3

package/src/Common/RJSF/common/FieldRow.tsx

@@ -0,0 +1,34 @@
+import { FieldRowProps } from './types'
+import { DEFAULT_FIELD_TITLE, DO_NOT_SHOW_LABEL } from '../constants'
+
+export const FieldRowWithLabel = ({
+    showLabel,
+    label,
+    required,
+    children,
+    id,
+    shouldAlignCenter = true,
+}: Omit<FieldRowProps, 'label'> & {
+    label: FieldRowProps['label'] | typeof DO_NOT_SHOW_LABEL
+}) => (
+    <div
+        className={
+            showLabel
+                ? `display-grid dc__gap-12 rjsf-form-template__field ${shouldAlignCenter ? 'flex-align-center' : ''}`
+                : ''
+        }
+    >
+        {showLabel && (
+            <label className="cn-7 fs-13 lh-32 fw-4 flexbox mb-0" htmlFor={id}>
+                {/* The check is added here intentionally for proper layout for array type field */}
+                {label !== DO_NOT_SHOW_LABEL && (
+                    <>
+                        <span className="dc__ellipsis-right">{label || DEFAULT_FIELD_TITLE}</span>
+                        {required && <span className="cr-5">&nbsp;*</span>}
+                    </>
+                )}
+            </label>
+        )}
+        {children}
+    </div>
+)

package/src/Common/RJSF/common/types.ts

@@ -0,0 +1,9 @@
+import { FieldTemplateProps } from '@rjsf/utils'
+
+export interface FieldRowProps extends Pick<FieldTemplateProps, 'children' | 'label' | 'required' | 'id'> {
+    showLabel?: boolean
+    /**
+     * @default true
+     */
+    shouldAlignCenter?: boolean
+}

package/src/Common/RJSF/config.ts

@@ -0,0 +1,36 @@
+import { RegistryWidgetsType } from '@rjsf/utils'
+
+import {
+    AddButton,
+    ArrayFieldItemTemplate,
+    ArrayFieldTemplate,
+    BaseInputTemplate,
+    DescriptionFieldTemplate,
+    FieldTemplate,
+    FieldErrorTemplate,
+    ObjectFieldTemplate,
+    RemoveButton,
+    SubmitButton,
+    TitleFieldTemplate,
+    WrapIfAdditionalTemplate,
+} from './templates'
+import { CheckboxWidget, SelectWidget } from './widgets'
+import { FormProps } from './types'
+
+export const widgets: RegistryWidgetsType = {
+    CheckboxWidget,
+    SelectWidget,
+}
+
+export const templates: FormProps['templates'] = {
+    ArrayFieldItemTemplate,
+    ArrayFieldTemplate,
+    BaseInputTemplate,
+    ButtonTemplates: { AddButton, RemoveButton, SubmitButton },
+    DescriptionFieldTemplate,
+    FieldTemplate,
+    FieldErrorTemplate,
+    ObjectFieldTemplate,
+    TitleFieldTemplate,
+    WrapIfAdditionalTemplate,
+}

package/src/Common/RJSF/constants.ts

@@ -0,0 +1,10 @@
+export const PLACEHOLDERS = {
+    SELECT: 'Please select an option',
+    INPUT: 'Please enter an input',
+    OBJECT_KEY: 'Please enter a value for the key',
+}
+
+export const DEFAULT_FIELD_TITLE = 'Key not available'
+
+// Using symbol to ensure uniqueness across the fields
+export const DO_NOT_SHOW_LABEL = Symbol('Do not show label')

package/src/Common/RJSF/index.ts

@@ -0,0 +1,3 @@
+export { RJSFForm } from './Form'
+export * from './types'
+export { getInferredTypeFromValueType, getRedirectionProps } from './utils'

package/src/Common/RJSF/rjsfForm.scss

@@ -0,0 +1,18 @@
+.rjsf-form-template {
+    &__field {
+        grid-template-columns: 250px 1fr;
+    }
+
+    &__additional-fields {
+        grid-template-columns: 1fr 1fr minmax(20px, auto);
+    }
+
+    &__array-field-item {
+        grid-template-columns: 1fr auto;
+
+        & > :first-child {
+            // This is added as the array field itself has a margin bottom
+            margin: 0;
+        }
+    }
+}

package/src/Common/RJSF/templates/ArrayFieldItemTemplate.tsx

@@ -0,0 +1,31 @@
+import { CSSProperties } from 'react'
+import { ArrayFieldTemplateItemType } from '@rjsf/utils'
+
+export const ArrayFieldItemTemplate = ({
+    children,
+    className,
+    disabled,
+    hasToolbar,
+    hasRemove,
+    index,
+    onDropIndexClick,
+    readonly,
+    registry,
+    uiSchema,
+}: ArrayFieldTemplateItemType) => {
+    const { RemoveButton } = registry.templates.ButtonTemplates
+
+    return (
+        <div className="display-grid rjsf-form-template__array-field-item flex-align-center dc__gap-8 mb-12">
+            {children}
+            {hasToolbar && hasRemove && (
+                <RemoveButton
+                    disabled={disabled || readonly}
+                    onClick={onDropIndexClick(index)}
+                    uiSchema={uiSchema}
+                    registry={registry}
+                />
+            )}
+        </div>
+    )
+}

package/src/Common/RJSF/templates/ArrayFieldTemplate.tsx

@@ -0,0 +1,77 @@
+import { getTemplate, getUiOptions, ArrayFieldTemplateProps, ArrayFieldTemplateItemType } from '@rjsf/utils'
+import { FieldRowWithLabel } from '../common/FieldRow'
+import { DO_NOT_SHOW_LABEL } from '../constants'
+
+const ActionButton = ({ canAdd, onAddClick, disabled, readonly, uiSchema, registry }) => {
+    const {
+        ButtonTemplates: { AddButton },
+    } = registry.templates
+
+    return (
+        canAdd && (
+            <AddButton onClick={onAddClick} disabled={disabled || readonly} uiSchema={uiSchema} registry={registry} />
+        )
+    )
+}
+
+export const ArrayFieldTemplate = ({
+    canAdd,
+    className,
+    disabled,
+    idSchema,
+    uiSchema,
+    items,
+    onAddClick,
+    readonly,
+    registry,
+    required,
+    title,
+}: ArrayFieldTemplateProps) => {
+    const uiOptions = getUiOptions(uiSchema)
+    const ArrayFieldItemTemplate = getTemplate<'ArrayFieldItemTemplate'>('ArrayFieldItemTemplate', registry, uiOptions)
+    const label = uiOptions.title || title
+
+    return (
+        <fieldset className={className} id={idSchema.$id}>
+            {/* Show the label here in case there are no items, otherwise handled by Field Template */}
+            {items.length ? (
+                <>
+                    {items.map(({ key, ...itemProps }: ArrayFieldTemplateItemType, index) => {
+                        // Show the title as the label for the first field
+                        const children = {
+                            ...itemProps.children,
+                            props: {
+                                ...itemProps.children.props,
+                                name: index === 0 ? label : DO_NOT_SHOW_LABEL,
+                            },
+                        }
+                        return (
+                            <ArrayFieldItemTemplate key={key} {...itemProps}>
+                                {children}
+                            </ArrayFieldItemTemplate>
+                        )
+                    })}
+                    <ActionButton
+                        canAdd={canAdd}
+                        onAddClick={onAddClick}
+                        disabled={disabled}
+                        readonly={readonly}
+                        uiSchema={uiSchema}
+                        registry={registry}
+                    />
+                </>
+            ) : (
+                <FieldRowWithLabel label={label} required={required} showLabel id={idSchema.$id}>
+                    <ActionButton
+                        canAdd={canAdd}
+                        onAddClick={onAddClick}
+                        disabled={disabled}
+                        readonly={readonly}
+                        uiSchema={uiSchema}
+                        registry={registry}
+                    />
+                </FieldRowWithLabel>
+            )}
+        </fieldset>
+    )
+}

package/src/Common/RJSF/templates/BaseInput.tsx

@@ -0,0 +1,15 @@
+import { getDefaultRegistry } from '@rjsf/core'
+import { BaseInputTemplateProps } from '@rjsf/utils'
+import { PLACEHOLDERS } from '../constants'
+
+const {
+    templates: { BaseInputTemplate },
+} = getDefaultRegistry()
+
+export const BaseInput = ({ placeholder, ...props }: BaseInputTemplateProps) => (
+    <BaseInputTemplate
+        placeholder={placeholder || PLACEHOLDERS.INPUT}
+        {...props}
+        className="form__input cn-9 fs-13 lh-20 fw-4"
+    />
+)

package/src/Common/RJSF/templates/ButtonTemplates/AddButton.tsx

@@ -0,0 +1,17 @@
+import { IconButtonProps } from '@rjsf/utils'
+
+import { ReactComponent as PlusIcon } from '../../../../Assets/Icon/ic-add.svg'
+
+export const AddButton = ({ icon, iconType, registry, uiSchema, ...props }: IconButtonProps) => (
+    <div className="flexbox flex-justify-end">
+        <button
+            {...props}
+            type="button"
+            className="dc__outline-none-imp p-0 dc__transparent flex dc__gap-4 cursor"
+            title="Add"
+        >
+            <PlusIcon className="icon-dim-16 fcb-5" />
+            <span className="cb-5 fs-13 lh-20">Add</span>
+        </button>
+    </div>
+)

package/src/Common/RJSF/templates/ButtonTemplates/RemoveButton.tsx

@@ -0,0 +1,9 @@
+import { IconButtonProps } from '@rjsf/utils'
+
+import { ReactComponent as CrossIcon } from '../../../../Assets/Icon/ic-cross.svg'
+
+export const RemoveButton = ({ icon, iconType, registry, uiSchema, ...props }: IconButtonProps) => (
+    <button {...props} type="button" className="dc__outline-none-imp p-0 dc__transparent flex cursor" title="Remove">
+        <CrossIcon className="icon-dim-16 fcr-5" />
+    </button>
+)

package/src/Common/RJSF/templates/ButtonTemplates/SubmitButton.tsx

@@ -0,0 +1,13 @@
+import { getSubmitButtonOptions, SubmitButtonProps } from '@rjsf/utils'
+
+export const SubmitButton = ({ uiSchema }: SubmitButtonProps) => {
+    const { submitText, norender, props: submitButtonProps = {} } = getSubmitButtonOptions(uiSchema)
+
+    return norender ? null : (
+        <div className="flexbox flex-justify-end">
+            <button type="submit" {...submitButtonProps} className={`cta ${submitButtonProps.className || ''}`}>
+                {submitText}
+            </button>
+        </div>
+    )
+}

package/src/Common/RJSF/templates/ButtonTemplates/index.ts

@@ -0,0 +1,3 @@
+export { AddButton } from './AddButton'
+export { RemoveButton } from './RemoveButton'
+export { SubmitButton } from './SubmitButton'

package/src/Common/RJSF/templates/Description.tsx

@@ -0,0 +1,11 @@
+import { DescriptionFieldProps } from '@rjsf/utils'
+
+import { ReactComponent as Info } from '../../../Assets/Icon/ic-info-filled.svg'
+
+export const Description = ({ id, description }: DescriptionFieldProps) =>
+    description && (
+        <div id={id} className="flex left flex-align-center mt-4 dc__gap-4">
+            <Info className="icon-dim-16 mw-16 info-icon-n5" />
+            <span className="cn-7 fs-11 fw-4 dc__ellipsis-right">{description}</span>
+        </div>
+    )

package/src/Common/RJSF/templates/Field.tsx

@@ -0,0 +1,41 @@
+import { FieldTemplateProps, getUiOptions, getTemplate, ADDITIONAL_PROPERTY_FLAG } from '@rjsf/utils'
+import { FieldRowWithLabel } from '../common/FieldRow'
+
+export const Field = (props: FieldTemplateProps) => {
+    const {
+        id,
+        label,
+        children,
+        errors,
+        hidden,
+        required,
+        displayLabel,
+        registry,
+        uiSchema,
+        classNames,
+        schema,
+        description,
+    } = props
+    const uiOptions = getUiOptions(uiSchema)
+    const WrapIfAdditionalTemplate = getTemplate<'WrapIfAdditionalTemplate'>(
+        'WrapIfAdditionalTemplate',
+        registry,
+        uiOptions,
+    )
+    // Object type fields have additional properties for key/value pairs
+    const hasAdditionalProperties = ADDITIONAL_PROPERTY_FLAG in schema
+    // Label is not displayed for boolean fields by default and hide for object type fields
+    const showLabel = (displayLabel || schema.type === 'boolean') && !hasAdditionalProperties
+
+    return hidden ? (
+        <div className="hidden">{children}</div>
+    ) : (
+        <div className={`${classNames} mb-12`}>
+            <FieldRowWithLabel label={label} showLabel={showLabel} id={id} required={required}>
+                <WrapIfAdditionalTemplate {...props}>{children}</WrapIfAdditionalTemplate>
+            </FieldRowWithLabel>
+            {description}
+            {errors}
+        </div>
+    )
+}

package/src/Common/RJSF/templates/FieldErrorTemplate.tsx

@@ -0,0 +1,22 @@
+import { errorId, FieldErrorProps } from '@rjsf/utils'
+
+import { ReactComponent as Error } from '../../../Assets/Icon/ic-warning.svg'
+
+export const FieldErrorTemplate = ({ errors = [], idSchema }: FieldErrorProps) => {
+    const id = errorId(idSchema)
+
+    return (
+        errors.length > 0 && (
+            <span id={id}>
+                {errors
+                    .filter((elem) => !!elem)
+                    .map((error, index: number) => (
+                        <span className="form__error" key={index}>
+                            <Error className="form__icon form__icon--error" />
+                            {error}
+                        </span>
+                    ))}
+            </span>
+        )
+    )
+}

package/src/Common/RJSF/templates/ObjectFieldTemplate.tsx

@@ -0,0 +1,103 @@
+import {
+    ObjectFieldTemplatePropertyType,
+    ObjectFieldTemplateProps,
+    canExpand,
+    getTemplate,
+    getUiOptions,
+    titleId,
+} from '@rjsf/utils'
+import { FieldRowWithLabel } from '../common/FieldRow'
+
+const Field = ({
+    disabled,
+    formData,
+    idSchema,
+    onAddClick,
+    properties,
+    readonly,
+    registry,
+    required,
+    schema,
+    title,
+    uiSchema,
+}: ObjectFieldTemplateProps) => {
+    const {
+        ButtonTemplates: { AddButton },
+    } = registry.templates
+    const hasAdditionalProperties = !!schema.additionalProperties
+
+    const ActionButton = canExpand(schema, uiSchema, formData) && (
+        <AddButton
+            className="object-property-expand"
+            onClick={onAddClick(schema)}
+            disabled={disabled || readonly}
+            uiSchema={uiSchema}
+            registry={registry}
+        />
+    )
+
+    const Properties = properties.map((prop: ObjectFieldTemplatePropertyType) => prop.content)
+
+    if (hasAdditionalProperties) {
+        if (properties.length) {
+            return (
+                <>
+                    <FieldRowWithLabel
+                        label={title}
+                        required={required}
+                        showLabel
+                        id={idSchema.$id}
+                        shouldAlignCenter={false}
+                    >
+                        <div>{Properties}</div>
+                    </FieldRowWithLabel>
+                    {ActionButton}
+                </>
+            )
+        }
+        return (
+            <FieldRowWithLabel label={title} required={required} showLabel id={idSchema.$id}>
+                {ActionButton}
+            </FieldRowWithLabel>
+        )
+    }
+    return (
+        <>
+            {Properties}
+            {ActionButton}
+        </>
+    )
+}
+
+export const ObjectFieldTemplate = (props: ObjectFieldTemplateProps) => {
+    const { idSchema, registry, required, schema, title, uiSchema } = props
+    const options = getUiOptions(uiSchema)
+    const TitleFieldTemplate = getTemplate('TitleFieldTemplate', registry, options)
+    const hasAdditionalProperties = !!schema.additionalProperties
+    const showTitle = title && !hasAdditionalProperties
+
+    return (
+        <fieldset id={idSchema.$id}>
+            {showTitle && (
+                <TitleFieldTemplate
+                    id={titleId(idSchema)}
+                    title={title}
+                    required={required}
+                    schema={schema}
+                    uiSchema={uiSchema}
+                    registry={registry}
+                />
+            )}
+            {/* Not adding the border and padding for non-objects and root schema */}
+            <div
+                className={
+                    schema.properties && !hasAdditionalProperties && idSchema.$id !== 'root'
+                        ? 'dc__border-left pl-12'
+                        : ''
+                }
+            >
+                <Field {...props} />
+            </div>
+        </fieldset>
+    )
+}

package/src/Common/RJSF/templates/TitleField.tsx

@@ -0,0 +1,8 @@
+import { TitleFieldProps } from '@rjsf/utils'
+
+export const TitleField = ({ id, title, required }: TitleFieldProps) => (
+    <legend className="fs-13 fw-6 cn-9 lh-20 pb-8 dc__border-bottom en-1 mb-12" id={id}>
+        <span>{title}</span>
+        {required && <span className="cr-5">&nbsp;*</span>}
+    </legend>
+)

package/src/Common/RJSF/templates/WrapIfAdditionalTemplate.tsx

@@ -0,0 +1,50 @@
+import { ADDITIONAL_PROPERTY_FLAG, WrapIfAdditionalTemplateProps } from '@rjsf/utils'
+
+import { PLACEHOLDERS } from '../constants'
+
+export const WrapIfAdditionalTemplate = ({
+    id,
+    disabled,
+    label,
+    onKeyChange,
+    onDropPropertyClick,
+    readonly,
+    schema,
+    children,
+    uiSchema,
+    registry,
+}: WrapIfAdditionalTemplateProps) => {
+    const { templates } = registry
+    const { RemoveButton } = templates.ButtonTemplates
+    const additional = ADDITIONAL_PROPERTY_FLAG in schema
+
+    return (
+        <>
+            {additional ? (
+                <div className="rjsf-form-template__additional-fields display-grid dc__gap-8 flex-align-center">
+                    <div>
+                        <input
+                            type="text"
+                            className="form__input cn-9 fs-13 lh-20 fw-4"
+                            id={`${id}-key`}
+                            onBlur={(event) => onKeyChange(event.target.value)}
+                            placeholder={PLACEHOLDERS.OBJECT_KEY}
+                            defaultValue={label}
+                        />
+                    </div>
+                    <div>{children}</div>
+                    <div>
+                        <RemoveButton
+                            disabled={disabled || readonly}
+                            onClick={onDropPropertyClick(label)}
+                            uiSchema={uiSchema}
+                            registry={registry}
+                        />
+                    </div>
+                </div>
+            ) : (
+                children
+            )}
+        </>
+    )
+}

package/src/Common/RJSF/templates/index.ts

@@ -0,0 +1,10 @@
+export { ArrayFieldTemplate } from './ArrayFieldTemplate'
+export { ArrayFieldItemTemplate } from './ArrayFieldItemTemplate'
+export { BaseInput as BaseInputTemplate } from './BaseInput'
+export * from './ButtonTemplates'
+export { Description as DescriptionFieldTemplate } from './Description'
+export { Field as FieldTemplate } from './Field'
+export { FieldErrorTemplate } from './FieldErrorTemplate'
+export { ObjectFieldTemplate } from './ObjectFieldTemplate'
+export { TitleField as TitleFieldTemplate } from './TitleField'
+export { WrapIfAdditionalTemplate } from './WrapIfAdditionalTemplate'

package/src/Common/RJSF/types.ts

@@ -0,0 +1,4 @@
+import { ComponentProps } from 'react'
+import RJSFForm from '@rjsf/core'
+
+export type FormProps = Omit<ComponentProps<typeof RJSFForm>, 'validator'>

package/src/Common/RJSF/utils.ts

@@ -0,0 +1,119 @@
+import { TranslatableString, englishStringTranslator } from '@rjsf/utils'
+
+/**
+ * Override for the TranslatableString from RJSF
+ */
+export const translateString = (stringToTranslate: TranslatableString, params?: string[]): string => {
+    switch (stringToTranslate) {
+        case TranslatableString.NewStringDefault:
+            // Use an empty string for the new additionalProperties string default value
+            return ''
+        default:
+            return englishStringTranslator(stringToTranslate, params)
+    }
+}
+
+export const getCommonSelectStyle = (styleOverrides = {}) => ({
+    menuList: (base) => ({
+        ...base,
+        paddingTop: 0,
+        paddingBottom: 0,
+    }),
+    control: (base, state) => ({
+        ...base,
+        minHeight: '32px',
+        boxShadow: 'none',
+        backgroundColor: 'var(--N50)',
+        border: state.isFocused ? '1px solid var(--B500)' : '1px solid var(--N200)',
+        cursor: 'pointer',
+    }),
+    option: (base, state) => ({
+        ...base,
+        color: 'var(--N900)',
+        backgroundColor: state.isFocused ? 'var(--N100)' : 'white',
+        padding: '10px 12px',
+    }),
+    dropdownIndicator: (base, state) => ({
+        ...base,
+        color: 'var(--N400)',
+        padding: '0 8px',
+        transition: 'all .2s ease',
+        transform: state.selectProps.menuIsOpen ? 'rotate(180deg)' : 'rotate(0deg)',
+    }),
+    valueContainer: (base, state) => ({
+        ...base,
+        padding: '0 8px',
+        fontWeight: '400',
+        color: state.selectProps.menuIsOpen ? 'var(--N500)' : base.color,
+    }),
+    loadingMessage: (base) => ({
+        ...base,
+        color: 'var(--N600)',
+    }),
+    noOptionsMessage: (base) => ({
+        ...base,
+        color: 'var(--N600)',
+    }),
+    multiValue: (base, state) => ({
+        ...base,
+        border: `1px solid var(--N200)`,
+        borderRadius: `4px`,
+        background: 'white',
+        height: '28px',
+        marginRight: '8px',
+        padding: '2px',
+        fontSize: '12px',
+    }),
+    ...styleOverrides,
+})
+
+/**
+ * Returns the redirection props for a url
+ */
+export const getRedirectionProps = (
+    url: string,
+): React.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    url: string
+} => {
+    try {
+        // The URL is validated when added using the form
+        const isInternalUrl = new URL(url).origin === window.location.origin
+        return {
+            href: url,
+            target: isInternalUrl ? '_self' : '_blank',
+            rel: isInternalUrl ? undefined : 'external noreferrer',
+            url,
+        }
+    } catch (err) {
+        return {
+            href: url,
+            target: '_blank',
+            url: `${url} (Invalid URL)`,
+        }
+    }
+}
+
+/**
+ * Infers the type for json schema from value type
+ */
+export const getInferredTypeFromValueType = (value) => {
+    const valueType = typeof value
+
+    switch (valueType) {
+        case 'boolean':
+        case 'string':
+        case 'number':
+            return valueType
+        case 'object':
+            if (Array.isArray(value)) {
+                return 'array'
+            }
+            if (value === null) {
+                return 'null'
+            }
+            return valueType
+        default:
+            // Unsupported or undefined types
+            return 'null'
+    }
+}