@strato-admin/faker-ecommerce 0.1.0 → 0.3.0

package/dist/ra-core/src/form/validation/useUnique.js

@@ -0,0 +1,107 @@
+import { useCallback, useRef } from 'react';
+import merge from 'lodash/merge.js';
+import set from 'lodash/set.js';
+import { useResourceContext } from '../../core';
+import { useDataProvider } from '../../dataProvider';
+import { useTranslate, useTranslateLabel } from '../../i18n';
+import { asyncDebounce } from '../../util';
+import { useRecordContext } from '../../controller';
+import { isEmpty } from './validate';
+/**
+ * A hook that returns a validation function checking for a record field uniqueness
+ * by calling the dataProvider getList function with a filter.
+ *
+ * @example // Passing options at declaration time
+ * const UserCreateForm = () => {
+ *     const unique = useUnique({ message: 'Username is already used'});
+ *     return (
+ *         <SimpleForm>
+ *             <TextInput source="username" validate={unique()} />
+ *         </SimpleForm>
+ *     );
+ * }
+ *
+ * @example // Passing options at call time
+ * const UserCreateForm = () => {
+ *     const unique = useUnique();
+ *     return (
+ *         <SimpleForm>
+ *             <TextInput source="username" validate={unique({ message: 'Username is already used'})} />
+ *         </SimpleForm>
+ *     );
+ * }
+ *
+ * @example // With additional filters
+ * const UserCreateForm = () => {
+ *     const unique = useUnique();
+ *     return (
+ *         <SimpleForm>
+ *             <ReferenceInput source="organization_id" reference="organizations" />
+ *             <FormDataConsumer>
+ *                 {({ formData }) => (
+ *                     <TextInput
+ *                         source="username"
+ *                         validate={unique({ filter: { organization_id: formData.organization_id })}
+ *                     />
+ *                 )}
+ *             </FormDataConsumer>
+ *         </SimpleForm>
+ *     );
+ * }
+ */
+export const useUnique = (options) => {
+    const dataProvider = useDataProvider();
+    const translateLabel = useTranslateLabel();
+    const resource = useResourceContext(options);
+    if (!resource) {
+        throw new Error('useUnique: missing resource prop or context');
+    }
+    const translate = useTranslate();
+    const record = useRecordContext();
+    const debouncedGetList = useRef(
+    // The initial value is here to set the correct type on useRef
+    asyncDebounce(dataProvider.getList, options?.debounce ?? DEFAULT_DEBOUNCE));
+    const validateUnique = useCallback((callTimeOptions) => {
+        const { message, filter, debounce: interval, } = merge({
+            debounce: DEFAULT_DEBOUNCE,
+            filter: {},
+            message: "strato.validation.unique',
+        }, options, callTimeOptions);
+        debouncedGetList.current = asyncDebounce(dataProvider.getList, interval);
+        return async (value, allValues, props) => {
+            if (isEmpty(value)) {
+                return undefined;
+            }
+            try {
+                const finalFilter = set(merge({}, filter), props.source, value);
+                const { data, total } = await debouncedGetList.current(resource, {
+                    filter: finalFilter,
+                    pagination: { page: 1, perPage: 1 },
+                    sort: { field: 'id', order: 'ASC' },
+                });
+                if (typeof total !== 'undefined' &&
+                    total > 0 &&
+                    !data.some(r => r.id === record?.id)) {
+                    return {
+                        message,
+                        args: {
+                            source: props.source,
+                            value,
+                            field: translateLabel({
+                                label: props.label,
+                                source: props.source,
+                                resource,
+                            }),
+                        },
+                    };
+                }
+            }
+            catch (error) {
+                return translate("strato.notification.http_error');
+            }
+            return undefined;
+        };
+    }, [dataProvider, options, record, resource, translate, translateLabel]);
+    return validateUnique;
+};
+const DEFAULT_DEBOUNCE = 1000;

package/dist/ra-core/src/form/validation/validate.d.ts

@@ -0,0 +1,168 @@
+export declare const isEmpty: (value: any) => boolean;
+export interface ValidationErrorMessageWithArgs {
+    message: string;
+    args: {
+        [key: string]: ValidationErrorMessageWithArgs | any;
+    };
+}
+export type ValidationErrorMessage = string | ValidationErrorMessageWithArgs;
+export type Validator = (value: any, values: any, props: any) => ValidationErrorMessage | null | undefined | Promise<ValidationErrorMessage | null | undefined>;
+export interface GetValidationMessageParams {
+    args: any;
+    value: any;
+    values: any;
+}
+export type GetValidationMessage = (params: GetValidationMessageParams) => ValidationErrorMessage;
+export declare const combine2Validators: (validator1: Validator, validator2: Validator) => Validator;
+export declare const composeValidators: (...validators: any[]) => Validator;
+export declare const composeSyncValidators: (...validators: any[]) => (value: any, values: any, meta: any) => ValidationErrorMessage | Promise<ValidationErrorMessage | null | undefined> | undefined;
+/**
+ * Required validator
+ *
+ * Returns an error if the value is null, undefined, or empty
+ *
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const titleValidators = [required('The title is required')];
+ * <TextInput name="title" validate={titleValidators} />
+ */
+export declare const required: (message?: any) => ((value: any, values: any) => string | {
+    message: string;
+    args: any;
+} | undefined) & {
+    isRequired: boolean;
+};
+/**
+ * Minimum length validator
+ *
+ * Returns an error if the value has a length less than the parameter
+ *
+ * @param {integer} min
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const passwordValidators = [minLength(10, 'Should be at least 10 characters')];
+ * <TextInput type="password" name="password" validate={passwordValidators} />
+ */
+export declare const minLength: (min: any, message?: any) => (value: any, values: any) => string | {
+    message: string;
+    args: any;
+} | undefined;
+/**
+ * Maximum length validator
+ *
+ * Returns an error if the value has a length higher than the parameter
+ *
+ * @param {integer} max
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const nameValidators = [maxLength(10, 'Should be at most 10 characters')];
+ * <TextInput name="name" validate={nameValidators} />
+ */
+export declare const maxLength: (max: any, message?: any) => (value: any, values: any) => string | {
+    message: string;
+    args: any;
+} | undefined;
+/**
+ * Minimum validator
+ *
+ * Returns an error if the value is less than the parameter
+ *
+ * @param {integer} min
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const fooValidators = [minValue(5, 'Should be more than 5')];
+ * <NumberInput name="foo" validate={fooValidators} />
+ */
+export declare const minValue: (min: any, message?: any) => (value: any, values: any) => string | {
+    message: string;
+    args: any;
+} | undefined;
+/**
+ * Maximum validator
+ *
+ * Returns an error if the value is higher than the parameter
+ *
+ * @param {integer} max
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const fooValidators = [maxValue(10, 'Should be less than 10')];
+ * <NumberInput name="foo" validate={fooValidators} />
+ */
+export declare const maxValue: (max: any, message?: any) => (value: any, values: any) => string | {
+    message: string;
+    args: any;
+} | undefined;
+/**
+ * Number validator
+ *
+ * Returns an error if the value is not a number
+ *
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const ageValidators = [number('Must be a number')];
+ * <TextInput name="age" validate={ageValidators} />
+ */
+export declare const number: (message?: any) => (value: any, values: any) => string | {
+    message: string;
+    args: any;
+} | undefined;
+/**
+ * Regular expression validator
+ *
+ * Returns an error if the value does not match the pattern given as parameter
+ *
+ * @param {RegExp} pattern
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const zipValidators = [regex(/^\d{5}(?:[-\s]\d{4})?$/, 'Must be a zip code')];
+ * <TextInput name="zip" validate={zipValidators} />
+ */
+export declare const regex: any;
+/**
+ * Email validator
+ *
+ * Returns an error if the value is not a valid email
+ *
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const emailValidators = [email('Must be an email')];
+ * <TextInput name="email" validate={emailValidators} />
+ */
+export declare const email: (message?: any) => any;
+/**
+ * Choices validator
+ *
+ * Returns an error if the value is not among the list passed as parameter
+ *
+ * @param {array} list
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const genderValidators = [choices(['male', 'female'], 'Must be either Male or Female')];
+ * <TextInput name="gender" validate={genderValidators} />
+ */
+export declare const choices: (list: any, message?: any) => (value: any, values: any) => string | {
+    message: string;
+    args: any;
+} | undefined;
+/**
+ * Given a validator, returns a boolean indicating whether the field is required or not.
+ */
+export declare const isRequired: (validate: any) => boolean;

package/dist/ra-core/src/form/validation/validate.js

@@ -0,0 +1,218 @@
+import lodashMemoize from 'lodash/memoize.js';
+/* @link http://stackoverflow.com/questions/46155/validate-email-address-in-javascript */
+const EMAIL_REGEX = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; // eslint-disable-line no-useless-escape
+export const isEmpty = (value) => typeof value === 'undefined' ||
+    value === null ||
+    value === '' ||
+    (Array.isArray(value) && value.length === 0);
+// type predicate, see https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates
+function isValidationErrorMessageWithArgs(error) {
+    return error ? error.hasOwnProperty('message') : false;
+}
+const getMessage = (message, messageArgs, value, values) => typeof message === 'function'
+    ? message({
+        args: messageArgs,
+        value,
+        values,
+    })
+    : messageArgs
+        ? {
+            message,
+            args: messageArgs,
+        }
+        : message;
+// If we define validation functions directly in JSX, it will
+// result in a new function at every render, and then trigger infinite re-render.
+// Hence, we memoize every built-in validator to prevent a "Maximum call stack" error.
+const memoize = (fn) => lodashMemoize(fn, (...args) => JSON.stringify(args));
+const isFunction = value => typeof value === 'function';
+export const combine2Validators = (validator1, validator2) => {
+    return (value, values, meta) => {
+        const result1 = validator1(value, values, meta);
+        if (!result1) {
+            return validator2(value, values, meta);
+        }
+        if (typeof result1 === 'string' ||
+            isValidationErrorMessageWithArgs(result1)) {
+            return result1;
+        }
+        return result1.then(resolvedResult1 => {
+            if (!resolvedResult1) {
+                return validator2(value, values, meta);
+            }
+            return resolvedResult1;
+        });
+    };
+};
+// Compose multiple validators into a single one for use with react-hook-form
+export const composeValidators = (...validators) => {
+    const allValidators = (Array.isArray(validators[0]) ? validators[0] : validators).filter(isFunction);
+    return allValidators.reduce(combine2Validators, () => null);
+};
+// Compose multiple validators into a single one for use with react-hook-form
+export const composeSyncValidators = (...validators) => (value, values, meta) => {
+    const allValidators = (Array.isArray(validators[0]) ? validators[0] : validators).filter(isFunction);
+    for (const validator of allValidators) {
+        const error = validator(value, values, meta);
+        if (error) {
+            return error;
+        }
+    }
+};
+/**
+ * Required validator
+ *
+ * Returns an error if the value is null, undefined, or empty
+ *
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const titleValidators = [required('The title is required')];
+ * <TextInput name="title" validate={titleValidators} />
+ */
+export const required = memoize((message = "strato.validation.required') => Object.assign((value, values) => isEmpty(value)
+    ? getMessage(message, undefined, value, values)
+    : undefined, { isRequired: true }));
+/**
+ * Minimum length validator
+ *
+ * Returns an error if the value has a length less than the parameter
+ *
+ * @param {integer} min
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const passwordValidators = [minLength(10, 'Should be at least 10 characters')];
+ * <TextInput type="password" name="password" validate={passwordValidators} />
+ */
+export const minLength = memoize((min, message = "strato.validation.minLength') => (value, values) => !isEmpty(value) && value.length < min
+    ? getMessage(message, { min }, value, values)
+    : undefined);
+/**
+ * Maximum length validator
+ *
+ * Returns an error if the value has a length higher than the parameter
+ *
+ * @param {integer} max
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const nameValidators = [maxLength(10, 'Should be at most 10 characters')];
+ * <TextInput name="name" validate={nameValidators} />
+ */
+export const maxLength = memoize((max, message = "strato.validation.maxLength') => (value, values) => !isEmpty(value) && value.length > max
+    ? getMessage(message, { max }, value, values)
+    : undefined);
+/**
+ * Minimum validator
+ *
+ * Returns an error if the value is less than the parameter
+ *
+ * @param {integer} min
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const fooValidators = [minValue(5, 'Should be more than 5')];
+ * <NumberInput name="foo" validate={fooValidators} />
+ */
+export const minValue = memoize((min, message = "strato.validation.minValue') => (value, values) => !isEmpty(value) && value < min
+    ? getMessage(message, { min }, value, values)
+    : undefined);
+/**
+ * Maximum validator
+ *
+ * Returns an error if the value is higher than the parameter
+ *
+ * @param {integer} max
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const fooValidators = [maxValue(10, 'Should be less than 10')];
+ * <NumberInput name="foo" validate={fooValidators} />
+ */
+export const maxValue = memoize((max, message = "strato.validation.maxValue') => (value, values) => !isEmpty(value) && value > max
+    ? getMessage(message, { max }, value, values)
+    : undefined);
+/**
+ * Number validator
+ *
+ * Returns an error if the value is not a number
+ *
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const ageValidators = [number('Must be a number')];
+ * <TextInput name="age" validate={ageValidators} />
+ */
+export const number = memoize((message = "strato.validation.number') => (value, values) => !isEmpty(value) && isNaN(Number(value))
+    ? getMessage(message, undefined, value, values)
+    : undefined);
+/**
+ * Regular expression validator
+ *
+ * Returns an error if the value does not match the pattern given as parameter
+ *
+ * @param {RegExp} pattern
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const zipValidators = [regex(/^\d{5}(?:[-\s]\d{4})?$/, 'Must be a zip code')];
+ * <TextInput name="zip" validate={zipValidators} />
+ */
+export const regex = lodashMemoize((pattern, message = "strato.validation.regex') => (value, values) => !isEmpty(value) && typeof value === 'string' && !pattern.test(value)
+    ? getMessage(message, { pattern }, value, values)
+    : undefined, (pattern, message) => {
+    return pattern.toString() + message;
+});
+/**
+ * Email validator
+ *
+ * Returns an error if the value is not a valid email
+ *
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const emailValidators = [email('Must be an email')];
+ * <TextInput name="email" validate={emailValidators} />
+ */
+export const email = memoize((message = "strato.validation.email') => regex(EMAIL_REGEX, message));
+const oneOfTypeMessage = ({ args }) => ({
+    message: "strato.validation.oneOf',
+    args,
+});
+/**
+ * Choices validator
+ *
+ * Returns an error if the value is not among the list passed as parameter
+ *
+ * @param {array} list
+ * @param {string|Function} message
+ *
+ * @example
+ *
+ * const genderValidators = [choices(['male', 'female'], 'Must be either Male or Female')];
+ * <TextInput name="gender" validate={genderValidators} />
+ */
+export const choices = memoize((list, message = oneOfTypeMessage) => (value, values) => !isEmpty(value) && list.indexOf(value) === -1
+    ? getMessage(message, { list }, value, values)
+    : undefined);
+/**
+ * Given a validator, returns a boolean indicating whether the field is required or not.
+ */
+export const isRequired = validate => {
+    if (validate && validate.isRequired) {
+        return true;
+    }
+    if (Array.isArray(validate)) {
+        return !!validate.find(it => it.isRequired);
+    }
+    return false;
+};

package/dist/ra-core/src/i18n/I18nContext.d.ts

@@ -0,0 +1,3 @@
+import { I18nProvider } from '../types';
+export type I18nContextProps = I18nProvider;
+export declare const I18nContext: import("react").Context<I18nProvider>;

package/dist/ra-core/src/i18n/I18nContext.js

@@ -0,0 +1,11 @@
+import { createContext } from 'react';
+import { substituteTokens } from './substituteTokens';
+const defaultI18nProvider = {
+    translate: (key, options) => options?._
+        ? substituteTokens(options._, options)
+        : substituteTokens(key, options),
+    changeLocale: () => Promise.resolve(),
+    getLocale: () => 'en',
+};
+export const I18nContext = createContext(defaultI18nProvider);
+I18nContext.displayName = 'I18nContext';

package/dist/ra-core/src/i18n/TranslatableContext.d.ts

@@ -0,0 +1,16 @@
+export declare const TranslatableContext: import("react").Context<TranslatableContextValue | undefined>;
+export interface TranslatableContextValue {
+    locales: string[];
+    selectedLocale: string;
+    selectLocale: SelectTranslatableLocale;
+    getRecordForLocale: GetRecordForLocale;
+}
+export type SelectTranslatableLocale = (locale: string) => void;
+/**
+ * Returns a record where translatable fields have their values set to the value of the given locale.
+ * This is necessary because the fields rely on the RecordContext to get their values and have no knowledge of the locale.
+ *
+ * Given the record { title: { en: 'title_en', fr: 'title_fr' } } and the locale 'fr',
+ * the record for the locale 'fr' will be { title: 'title_fr' }
+ */
+export type GetRecordForLocale = (record: any, locale: string) => any;

package/dist/ra-core/src/i18n/TranslatableContext.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const TranslatableContext = createContext(undefined);