@strato-admin/core 0.1.1 → 0.3.0

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/I18nContextProvider.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { I18nProvider } from '../types';
+/**
+ * Store the i18nProvider in a context, and rerender children when the locale changes
+ */
+export declare const I18nContextProvider: ({ value, children, }: I18nContextProviderProps) => import("react/jsx-runtime").JSX.Element | null;
+export interface I18nContextProviderProps {
+    value?: I18nProvider;
+    children: ReactNode;
+}

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

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { I18nContext } from './I18nContext';
+import { useStore } from '../store/useStore';
+import { useNotify } from '../notification';
+/**
+ * Store the i18nProvider in a context, and rerender children when the locale changes
+ */
+export const I18nContextProvider = ({ value = defaulti18nContext, children, }) => {
+    const [locale] = useStore('locale');
+    const notify = useNotify();
+    const [key, setKey] = useState(0);
+    // to avoid blinking effect, delay first render if the user has a non-default locale
+    const [isInitialized, setInitialized] = useState(locale === value.getLocale());
+    // watch store for locale changes
+    useEffect(() => {
+        if (locale && value.getLocale() !== locale) {
+            new Promise(resolve => {
+                // so we systematically return a Promise for the messages
+                // i18nProvider may return a Promise for language changes,
+                resolve(value.changeLocale(locale));
+            })
+                .then(() => {
+                // Force full page re-render.
+                // This is slow on locale change, but it's a good way
+                // to avoid having one subscription to the locale
+                // for each call to translate()
+                setKey(key => key + 1);
+                setInitialized(true);
+            })
+                .catch(error => {
+                setInitialized(true);
+                notify("strato.notification.i18n_error', { type: 'error' });
+                console.error(error);
+            });
+        }
+        else {
+            setInitialized(true);
+        }
+    }, [value, locale, notify]);
+    return isInitialized ? (_jsx(I18nContext.Provider, { value: value, children: children }, key)) : null;
+};
+const defaulti18nContext = {
+    translate: x => x,
+    changeLocale: () => Promise.resolve(),
+    getLocale: () => 'en',
+};

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

@@ -0,0 +1,8 @@
+import { I18nProvider } from '../types';
+export declare const TestTranslationProvider: ({ translate, messages, children, }: any) => import("react/jsx-runtime").JSX.Element;
+export interface IMessages extends Record<string, string | ((options?: any) => string) | IMessages> {
+}
+export declare const testI18nProvider: ({ translate, messages, }?: {
+    translate?: I18nProvider["translate"];
+    messages?: IMessages;
+}) => I18nProvider;

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

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import lodashGet from 'lodash/get.js';
+import { I18nContextProvider } from './I18nContextProvider';
+export const TestTranslationProvider = ({ translate, messages, children, }) => (_jsx(I18nContextProvider, { value: testI18nProvider({ translate, messages }), children: children }));
+export const testI18nProvider = ({ translate, messages, } = {}) => {
+    return {
+        translate: messages
+            ? (key, options) => {
+                const message = lodashGet(messages, key);
+                return message
+                    ? typeof message === 'function'
+                        ? message(options)
+                        : message
+                    : options?._;
+            }
+            : translate || (key => key),
+        changeLocale: () => Promise.resolve(),
+        getLocale: () => 'en',
+    };
+};

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);

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

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { TranslatableContextValue } from './TranslatableContext';
+export declare const TranslatableContextProvider: ({ children, value, }: {
+    children: ReactNode;
+    value: TranslatableContextValue;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { TranslatableContext, } from './TranslatableContext';
+export const TranslatableContextProvider = ({ children, value, }) => {
+    return (_jsx(TranslatableContext.Provider, { value: value, children: children }));
+};

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

@@ -0,0 +1,7 @@
+import React, { ReactNode } from 'react';
+export declare const Translate: ({ i18nKey, options, children }: TranslateProps) => string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
+export interface TranslateProps {
+    i18nKey: string;
+    children?: ReactNode;
+    options?: Object;
+}

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

@@ -0,0 +1,10 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useTranslate } from './useTranslate';
+export const Translate = ({ i18nKey, options, children }) => {
+    const translate = useTranslate();
+    const translatedMessage = translate(i18nKey, typeof children === 'string' ? { _: children, ...options } : options);
+    if (translatedMessage) {
+        return _jsx(_Fragment, { children: translatedMessage });
+    }
+    return children;
+};

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

@@ -0,0 +1,221 @@
+export interface StringMap {
+    [key: string]: StringMap | string | undefined;
+}
+export interface TranslationMessages extends StringMap {
+    ra: {
+        action: {
+            [key: string]: StringMap | string;
+            add_filter: string;
+            add: string;
+            back: string;
+            bulk_actions: string;
+            cancel: string;
+            clear_array_input: string;
+            clear_input_value: string;
+            clone: string;
+            confirm: string;
+            create: string;
+            create_item: string;
+            delete: string;
+            edit: string;
+            export: string;
+            list: string;
+            refresh: string;
+            remove_filter: string;
+            remove_all_filters: string;
+            remove: string;
+            reset: string;
+            save: string;
+            search: string;
+            search_columns: string;
+            select_all: string;
+            select_all_button: string;
+            select_row: string;
+            show: string;
+            sort: string;
+            undo: string;
+            unselect: string;
+            expand: string;
+            close: string;
+            open_menu: string;
+            close_menu: string;
+            update: string;
+            move_up: string;
+            move_down: string;
+            open: string;
+            toggle_theme: string;
+            select_columns: string;
+            update_application: string;
+        };
+        boolean: {
+            [key: string]: StringMap | string;
+            true: string;
+            false: string;
+            null: string;
+        };
+        page: {
+            [key: string]: StringMap | string;
+            create: string;
+            dashboard: string;
+            edit: string;
+            error: string;
+            list: string;
+            loading: string;
+            not_found: string;
+            show: string;
+            empty: string;
+            invite: string;
+            access_denied: string;
+            authentication_error: string;
+        };
+        input: {
+            [key: string]: StringMap | string;
+            file: {
+                [key: string]: StringMap | string;
+                upload_several: string;
+                upload_single: string;
+            };
+            image: {
+                [key: string]: StringMap | string;
+                upload_several: string;
+                upload_single: string;
+            };
+            references: {
+                [key: string]: StringMap | string;
+                all_missing: string;
+                many_missing: string;
+                single_missing: string;
+            };
+            password: {
+                [key: string]: StringMap | string;
+                toggle_visible: string;
+                toggle_hidden: string;
+            };
+        };
+        message: {
+            [key: string]: StringMap | string;
+            about: string;
+            access_denied: string;
+            are_you_sure: string;
+            authentication_error: string;
+            auth_error: string;
+            bulk_delete_content: string;
+            bulk_delete_title: string;
+            bulk_update_content: string;
+            bulk_update_title: string;
+            clear_array_input: string;
+            delete_content: string;
+            delete_title: string;
+            details: string;
+            error: string;
+            invalid_form: string;
+            loading: string;
+            no: string;
+            not_found: string;
+            select_all_limit_reached: string;
+            unsaved_changes: string;
+            yes: string;
+            placeholder_data_warning: string;
+        };
+        navigation: {
+            [key: string]: StringMap | string;
+            no_results: string;
+            no_filtered_results: string;
+            clear_filters: string;
+            no_more_results: string;
+            page_out_of_boundaries: string;
+            page_out_from_end: string;
+            page_out_from_begin: string;
+            page_range_info: string;
+            partial_page_range_info: string;
+            page_rows_per_page: string;
+            current_page: string;
+            page: string;
+            first: string;
+            last: string;
+            next: string;
+            previous: string;
+            skip_nav: string;
+        };
+        sort: {
+            sort_by: string;
+            ASC: string;
+            DESC: string;
+        };
+        auth: {
+            [key: string]: StringMap | string;
+            auth_check_error: string;
+            user_menu: string;
+            username: string;
+            password: string;
+            email: string;
+            sign_in: string;
+            sign_in_error: string;
+            logout: string;
+        };
+        notification: {
+            [key: string]: StringMap | string;
+            updated: string;
+            created: string;
+            deleted: string;
+            bad_item: string;
+            item_doesnt_exist: string;
+            http_error: string;
+            data_provider_error: string;
+            i18n_error: string;
+            canceled: string;
+            logged_out: string;
+            not_authorized: string;
+            application_update_available: string;
+            offline: string;
+        };
+        validation: {
+            [key: string]: StringMap | string;
+            required: string;
+            minLength: string;
+            maxLength: string;
+            minValue: string;
+            maxValue: string;
+            number: string;
+            email: string;
+            oneOf: string;
+            regex: string;
+        };
+        saved_queries: {
+            label: string;
+            query_name: string;
+            new_label: string;
+            new_dialog_title: string;
+            remove_label: string;
+            remove_label_with_name: string;
+            remove_dialog_title: string;
+            remove_message: string;
+            help: string;
+        };
+        configurable?: {
+            customize: string;
+            configureMode: string;
+            inspector: {
+                title: string;
+                content: string;
+                reset: string;
+                hideAll: string;
+                showAll: string;
+            };
+            Datagrid: {
+                title: string;
+                unlabeled: string;
+            };
+            SimpleForm: {
+                title: string;
+                unlabeled: string;
+            };
+            SimpleList: {
+                title: string;
+                primaryText: string;
+                secondaryText: string;
+                tertiaryText: string;
+            };
+        };
+    };
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,60 @@
+/**
+ * Resolve the browser locale according to the value of the global window.navigator
+ *
+ * Use it to determine the <Admin> locale at runtime.
+ *
+ * @example
+ *    import * as React from "react";
+ *    import { Admin, Resource, resolveBrowserLocale } from 'react-admin';
+ *    import polyglotI18nProvider from 'ra-i18n-polyglot';
+ *    import englishMessages from 'ra-language-english';
+ *    import frenchMessages from 'ra-language-french';
+ *
+ *    const messages = {
+ *        fr: frenchMessages,
+ *        en: englishMessages,
+ *    };
+ *    const i18nProvider = polyglotI18nProvider(
+ *        locale => messages[locale] ? messages[locale] : messages.en,
+ *        resolveBrowserLocale()
+ *    );
+ *
+ *    const App = () => (
+ *        <Admin i18nProvider={i18nProvider}>
+ *            ...
+ *        </Admin>
+ *    );
+ *
+ * @param {string} defaultLocale Defaults to 'en'
+ * @param options
+ * @param {boolean} options.fullLocale Defaults to false
+ */
+export declare const resolveBrowserLocale: (defaultLocale?: string, options?: {
+    fullLocale?: boolean;
+}) => string;
+/**
+ * Compose translations from multiple packages for a single language (eg: 'english').
+ *
+ * Use it to merge translations from addons with the main react-admin translations.
+ *
+ * @example
+ *     import * as React from "react";
+ *     import { Admin, Resource, mergeTranslations } from 'react-admin';
+ *     import polyglotI18nProvider from 'ra-i18n-polyglot';
+ *     import englishMessages from 'ra-language-english';
+ *     import englishTreeMessages from 'ra-tree-language-english';
+ *
+ *     const messages = {
+ *        en: mergeTranslations(englishMessages, englishTreeMessages),
+ *     };
+ *     const i18nProvider = polyglotI18nProvider(
+ *        locale => messages[locale] ? messages[locale] : messages.en
+ *    );
+ *
+ *    const App = () => (
+ *        <Admin i18nProvider={i18nProvider}>
+ *            ...
+ *        </Admin>
+ *    );
+ */
+export declare const mergeTranslations: (...translationsModules: object[]) => any;