@strato-admin/faker-ecommerce 0.1.0 → 0.3.0

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

@@ -0,0 +1,31 @@
+import { TranslatableContextValue } from './TranslatableContext';
+/**
+ * Gives access to the current TranslatableContext.
+ *
+ * @example
+ * <TranslatableFields
+ *     selector={<MyLanguageSelector />}
+ *     locales={['en', 'fr']}
+ * >
+ *     <TextField source={getSource('title')} />
+ * <TranslatableFields>
+ *
+ * const MyLanguageSelector = () => {
+ *     const {
+ *         locales,
+ *         selectedLocale,
+ *         selectLocale,
+ *     } = useTranslatableContext();
+ *
+ *     return (
+ *         <select onChange={selectLocale}>
+ *             {locales.map((locale) => (
+ *                 <option selected={locale.locale === selectedLocale}>
+ *                     {locale.name}
+ *                 </option>
+ *             ))}
+ *        </select>
+ *     );
+ * }
+ */
+export declare const useTranslatableContext: () => TranslatableContextValue;

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

@@ -0,0 +1,38 @@
+import { useContext } from 'react';
+import { TranslatableContext, } from './TranslatableContext';
+/**
+ * Gives access to the current TranslatableContext.
+ *
+ * @example
+ * <TranslatableFields
+ *     selector={<MyLanguageSelector />}
+ *     locales={['en', 'fr']}
+ * >
+ *     <TextField source={getSource('title')} />
+ * <TranslatableFields>
+ *
+ * const MyLanguageSelector = () => {
+ *     const {
+ *         locales,
+ *         selectedLocale,
+ *         selectLocale,
+ *     } = useTranslatableContext();
+ *
+ *     return (
+ *         <select onChange={selectLocale}>
+ *             {locales.map((locale) => (
+ *                 <option selected={locale.locale === selectedLocale}>
+ *                     {locale.name}
+ *                 </option>
+ *             ))}
+ *        </select>
+ *     );
+ * }
+ */
+export const useTranslatableContext = () => {
+    const context = useContext(TranslatableContext);
+    if (!context) {
+        throw new Error('useTranslatableContext must be used inside a TranslatableContextProvider');
+    }
+    return context;
+};

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

@@ -0,0 +1,21 @@
+import { TranslateFunction } from '../types';
+/**
+ * Translate a string using the current locale and the translations from the i18nProvider
+ *
+ * @see Polyglot.t()
+ * @link https://airbnb.io/polyglot.js/#polyglotprototypetkey-interpolationoptions
+ *
+ * @return {Function} A translation function, accepting two arguments
+ *   - a string used as key in the translations
+ *   - an interpolationOptions object
+ *
+ * @example
+ *
+ * import { useTranslate } from 'react-admin';
+ *
+ * const SettingsMenu = () => {
+ *     const translate = useTranslate();
+ *     return <MenuItem>{translate('settings')}</MenuItem>;
+ * }
+ */
+export declare const useTranslate: () => TranslateFunction;

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

@@ -0,0 +1,29 @@
+import { useCallback } from 'react';
+import { useI18nProvider } from './useI18nProvider';
+/**
+ * Translate a string using the current locale and the translations from the i18nProvider
+ *
+ * @see Polyglot.t()
+ * @link https://airbnb.io/polyglot.js/#polyglotprototypetkey-interpolationoptions
+ *
+ * @return {Function} A translation function, accepting two arguments
+ *   - a string used as key in the translations
+ *   - an interpolationOptions object
+ *
+ * @example
+ *
+ * import { useTranslate } from 'react-admin';
+ *
+ * const SettingsMenu = () => {
+ *     const translate = useTranslate();
+ *     return <MenuItem>{translate('settings')}</MenuItem>;
+ * }
+ */
+export const useTranslate = () => {
+    const i18nProvider = useI18nProvider();
+    const translate = useCallback((key, options) => i18nProvider.translate(key, options), 
+    // update the hook each time the locale changes
+    [i18nProvider]);
+    return i18nProvider ? translate : identity;
+};
+const identity = key => key;

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

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export declare const useTranslateLabel: () => ({ source, label, resource, }: {
+    source?: string;
+    label?: ReactNode;
+    resource?: string;
+}) => string | number | bigint | true | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null;

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

@@ -0,0 +1,26 @@
+import { useCallback } from 'react';
+import { useTranslate } from './useTranslate';
+import { getFieldLabelTranslationArgs } from '../util';
+import { useResourceContext, useOptionalSourceContext } from '../core';
+export const useTranslateLabel = () => {
+    const translate = useTranslate();
+    const resourceFromContext = useResourceContext();
+    const sourceContext = useOptionalSourceContext();
+    return useCallback(({ source, label, resource, }) => {
+        if (label === false || label === '') {
+            return null;
+        }
+        if (label && typeof label !== 'string') {
+            return label;
+        }
+        return translate(...getFieldLabelTranslationArgs({
+            label: label,
+            defaultLabel: source
+                ? sourceContext?.getLabel(source)
+                : undefined,
+            resource,
+            resourceFromContext,
+            source,
+        }));
+    }, [resourceFromContext, translate, sourceContext]);
+};

package/dist/ra-core/src/index.d.ts

@@ -0,0 +1,16 @@
+export * from './auth';
+export * from './controller';
+export * from './core';
+export * from './preferences';
+export * from './dataProvider';
+export * from './dataTable';
+export * from './export';
+export * from './form';
+export * from './i18n';
+export * from './inference';
+export * from './notification';
+export * from './routing';
+export * from './store';
+export * from './types';
+export * from './util';
+export * as testUI from './test-ui';

package/dist/ra-core/src/index.js

@@ -0,0 +1,16 @@
+export * from './auth';
+export * from './controller';
+export * from './core';
+export * from './preferences';
+export * from './dataProvider';
+export * from './dataTable';
+export * from './export';
+export * from './form';
+export * from './i18n';
+export * from './inference';
+export * from './notification';
+export * from './routing';
+export * from './store';
+export * from './types';
+export * from './util';
+export * as testUI from './test-ui';

package/dist/ra-core/src/inference/InferredElement.d.ts

@@ -0,0 +1,12 @@
+import { InferredType } from './types';
+declare class InferredElement {
+    type?: InferredType;
+    props?: any;
+    children?: any;
+    constructor(type?: InferredType, props?: any, children?: any);
+    getElement(props?: {}): import("react").ReactElement<{}, string | import("react").JSXElementConstructor<any>> | undefined;
+    getProps(): any;
+    isDefined(): boolean;
+    getRepresentation(): string;
+}
+export default InferredElement;

package/dist/ra-core/src/inference/InferredElement.js

@@ -0,0 +1,40 @@
+import { createElement } from 'react';
+class InferredElement {
+    type;
+    props;
+    children;
+    constructor(type, props, children) {
+        this.type = type;
+        this.props = props;
+        this.children = children;
+    }
+    getElement(props = {}) {
+        if (!this.type || !this.type.component) {
+            return;
+        }
+        return this.children
+            ? createElement(this.type.component, { ...this.props, ...props }, this.children.length > 0
+                ? this.children.map((child, index) => child.getElement({ key: index }))
+                : this.children.getElement())
+            : createElement(this.type.component, { ...this.props, ...props });
+    }
+    getProps() {
+        return this.props;
+    }
+    isDefined() {
+        return !!this.type;
+    }
+    getRepresentation() {
+        if (!this.type) {
+            return '';
+        }
+        if (this.type.representation) {
+            return this.type.representation(this.props, this.children);
+        }
+        if (this.type.component) {
+            return `<${this.type.component.displayName || this.type.component.name} source="${this.props.source}" />`;
+        }
+        return '';
+    }
+}
+export default InferredElement;

package/dist/ra-core/src/inference/assertions.d.ts

@@ -0,0 +1,26 @@
+export declare const isNumeric: (value: any) => boolean;
+export declare const valuesAreNumeric: (values: any[]) => boolean;
+export declare const isInteger: (value: any) => boolean;
+export declare const valuesAreInteger: (values: any[]) => boolean;
+export declare const isBoolean: (value: any) => value is boolean;
+export declare const valuesAreBoolean: (values: any[]) => values is boolean[];
+export declare const isBooleanString: (value: any) => boolean;
+export declare const valuesAreBooleanString: (values: any[]) => boolean;
+export declare const isString: (value: any) => value is string;
+export declare const valuesAreString: (values: any[]) => values is string[];
+export declare const isHtml: (value: any) => boolean;
+export declare const valuesAreHtml: (values: any[]) => boolean;
+export declare const isUrl: (value: any) => value is string;
+export declare const valuesAreUrl: (values: any[]) => values is string[];
+export declare const isImageUrl: (value: any) => value is string;
+export declare const valuesAreImageUrl: (values: any[]) => values is string[];
+export declare const isEmail: (value: any) => value is string;
+export declare const valuesAreEmail: (values: any[]) => values is string[];
+export declare const isArray: (value: any) => value is Array<any>;
+export declare const valuesAreArray: (values: any[]) => values is Array<any>[];
+export declare const isDate: (value: any) => value is Date;
+export declare const valuesAreDate: (values: any[]) => values is Date[];
+export declare const isDateString: (value: any) => value is string;
+export declare const valuesAreDateString: (values: any[]) => values is string[];
+export declare const isObject: (value: any) => value is object;
+export declare const valuesAreObject: (values: any[]) => values is Array<object>;

package/dist/ra-core/src/inference/assertions.js

@@ -0,0 +1,38 @@
+import { isMatch, isValid, parseISO } from 'date-fns';
+export const isNumeric = (value) => !isNaN(parseFloat(value)) && isFinite(value);
+export const valuesAreNumeric = (values) => values.every(isNumeric);
+export const isInteger = (value) => Number.isInteger(value) || !isNaN(parseInt(value));
+export const valuesAreInteger = (values) => values.every(isInteger);
+export const isBoolean = (value) => typeof value === 'boolean';
+export const valuesAreBoolean = (values) => values.every(isBoolean);
+export const isBooleanString = (value) => ['true', 'false'].includes(value.toString().toLowerCase());
+export const valuesAreBooleanString = (values) => values.every(isBooleanString);
+export const isString = (value) => typeof value === 'string';
+export const valuesAreString = (values) => values.every(isString);
+const HtmlRegexp = /<([A-Z][A-Z0-9]*)\b[^>]*>(.*?)<\/\1>/i;
+export const isHtml = (value) => !value || HtmlRegexp.test(value);
+export const valuesAreHtml = (values) => values.every(isHtml);
+const UrlRegexp = /http(s*):\/\/.*/i;
+export const isUrl = (value) => !value || UrlRegexp.test(value);
+export const valuesAreUrl = (values) => values.every(isUrl);
+const ImageUrlRegexp = /^http(s*):\/\/.*\.(jpeg|jpg|jfif|pjpeg|pjp|png|svg|gif|webp|apng|bmp|ico|cur|tif|tiff)/i;
+export const isImageUrl = (value) => !value || ImageUrlRegexp.test(value);
+export const valuesAreImageUrl = (values) => values.every(isImageUrl);
+// This is a very simple regex to find emails
+// It is NOT meant to validate emails as the spec is way more complicated but is
+// enough for our inference needs
+const EmailRegexp = /@{1}/;
+export const isEmail = (value) => !value || EmailRegexp.test(value);
+export const valuesAreEmail = (values) => values.every(isEmail);
+export const isArray = (value) => Array.isArray(value);
+export const valuesAreArray = (values) => values.every(isArray);
+export const isDate = (value) => !value || value instanceof Date;
+export const valuesAreDate = (values) => values.every(isDate);
+export const isDateString = (value) => !value ||
+    (typeof value === 'string' &&
+        (isMatch(value, 'MM/dd/yyyy') ||
+            isMatch(value, 'MM/dd/yy') ||
+            isValid(parseISO(value))));
+export const valuesAreDateString = (values) => values.every(isDateString);
+export const isObject = (value) => Object.prototype.toString.call(value) === '[object Object]';
+export const valuesAreObject = (values) => values.every(isObject);

package/dist/ra-core/src/inference/getElementsFromRecords.d.ts

@@ -0,0 +1,35 @@
+import { InferredTypeMap } from './types';
+import InferredElement from './InferredElement';
+/**
+ * Get a list of React-admin field components from a list of records
+ *
+ * @example
+ * const records = [
+ *     {
+ *         "id": 1,
+ *         "title": "Lorem Ipsum",
+ *         "views": 254,
+ *         "user_id": 123,
+ *     },
+ *     {
+ *         "id": 2,
+ *         "title": "Sic Dolor amet",
+ *         "user_id": 456,
+ *     },
+ * ];
+ * const types = {
+ *     id: NumberField,
+ *     string: TextField,
+ *     number: NumberField,
+ *     reference: ReferenceField
+ * };
+ * const components = getElementsFromRecords(records, types);
+ * // [
+ * //    <NumberField source="id" />,
+ * //    <TextField source="title" />,
+ * //    <NumberField source="views" />,
+ * //    <ReferenceField source="user_id" reference="users"><NumberField source="id" /></ReferenceField>,
+ * // ];
+ */
+declare const _default: (records: any[], types: InferredTypeMap) => InferredElement[];
+export default _default;

package/dist/ra-core/src/inference/getElementsFromRecords.js

@@ -0,0 +1,39 @@
+import inferElementFromValues from './inferElementFromValues';
+import getValuesFromRecords from './getValuesFromRecords';
+/**
+ * Get a list of React-admin field components from a list of records
+ *
+ * @example
+ * const records = [
+ *     {
+ *         "id": 1,
+ *         "title": "Lorem Ipsum",
+ *         "views": 254,
+ *         "user_id": 123,
+ *     },
+ *     {
+ *         "id": 2,
+ *         "title": "Sic Dolor amet",
+ *         "user_id": 456,
+ *     },
+ * ];
+ * const types = {
+ *     id: NumberField,
+ *     string: TextField,
+ *     number: NumberField,
+ *     reference: ReferenceField
+ * };
+ * const components = getElementsFromRecords(records, types);
+ * // [
+ * //    <NumberField source="id" />,
+ * //    <TextField source="title" />,
+ * //    <NumberField source="views" />,
+ * //    <ReferenceField source="user_id" reference="users"><NumberField source="id" /></ReferenceField>,
+ * // ];
+ */
+export default (records, types) => {
+    const fieldValues = getValuesFromRecords(records);
+    return Object.keys(fieldValues)
+        .reduce((fields, fieldName) => fields.concat(inferElementFromValues(fieldName, fieldValues[fieldName], types)), [])
+        .filter(inferredElement => inferredElement.isDefined());
+};

package/dist/ra-core/src/inference/getValuesFromRecords.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Gets a list of values indexed by field based on a list of records
+ *
+ * @example
+ * const records = [
+ *     {
+ *         id: 1,
+ *         title: "Lorem Ipsum",
+ *         views: 254,
+ *         user_id: 123,
+ *     },
+ *     {
+ *         id: 2,
+ *         title: "Sic Dolor amet",
+ *         views: 65,
+ *         user_id: 456,
+ *     },
+ * ];
+ * getValuesFromRecords(records);
+ * // {
+ * //    id: [1, 2],
+ * //    title: ['Lorem Ipsum', 'Sic Dolor amet'],
+ * //    views: [254, 65],
+ * //    user_id: [123, 456],
+ * // }
+ */
+declare const _default: (records: any[]) => any;
+export default _default;

package/dist/ra-core/src/inference/getValuesFromRecords.js

@@ -0,0 +1,40 @@
+/**
+ * Gets a list of values indexed by field based on a list of records
+ *
+ * @example
+ * const records = [
+ *     {
+ *         id: 1,
+ *         title: "Lorem Ipsum",
+ *         views: 254,
+ *         user_id: 123,
+ *     },
+ *     {
+ *         id: 2,
+ *         title: "Sic Dolor amet",
+ *         views: 65,
+ *         user_id: 456,
+ *     },
+ * ];
+ * getValuesFromRecords(records);
+ * // {
+ * //    id: [1, 2],
+ * //    title: ['Lorem Ipsum', 'Sic Dolor amet'],
+ * //    views: [254, 65],
+ * //    user_id: [123, 456],
+ * // }
+ */
+export default (records) => records.reduce((values, record) => {
+    Object.keys(record).forEach(fieldName => {
+        if (!values[fieldName]) {
+            values[fieldName] = [];
+        }
+        if (record[fieldName] != null) {
+            const value = Array.isArray(record[fieldName])
+                ? [record[fieldName]]
+                : record[fieldName];
+            values[fieldName] = values[fieldName].concat(value);
+        }
+    });
+    return values;
+}, {});

package/dist/ra-core/src/inference/index.d.ts

@@ -0,0 +1,6 @@
+import getElementsFromRecords from './getElementsFromRecords';
+import InferredElement from './InferredElement';
+import getValuesFromRecords from './getValuesFromRecords';
+export * from './inferTypeFromValues';
+export * from './types';
+export { getElementsFromRecords, getValuesFromRecords, InferredElement };

package/dist/ra-core/src/inference/index.js

@@ -0,0 +1,6 @@
+import getElementsFromRecords from './getElementsFromRecords';
+import InferredElement from './InferredElement';
+import getValuesFromRecords from './getValuesFromRecords';
+export * from './inferTypeFromValues';
+export * from './types';
+export { getElementsFromRecords, getValuesFromRecords, InferredElement };

package/dist/ra-core/src/inference/inferTypeFromValues.d.ts

@@ -0,0 +1,21 @@
+export declare const InferenceTypes: readonly ["array", "boolean", "date", "email", "id", "image", "number", "reference", "referenceChild", "referenceArray", "referenceArrayChild", "richText", "string", "url", "object"];
+export type PossibleInferredElementTypes = (typeof InferenceTypes)[number];
+export interface InferredElementDescription {
+    type: PossibleInferredElementTypes;
+    props?: any;
+    children?: InferredElementDescription | InferredElementDescription[];
+}
+/**
+ * Guesses an element type based on an array of values
+ *
+ * @example
+ *     inferElementFromValues(
+ *         'address',
+ *         ['2 Baker Street', '1 Downing street'],
+ *     );
+ *     // { type: 'string', props: { source: 'address' } }
+ *
+ * @param {string} name Property name, e.g. 'date_of_birth'
+ * @param {any[]} values an array of values from which to determine the type, e.g. [12, 34.4, 43]
+ */
+export declare const inferTypeFromValues: (name: any, values?: any[]) => InferredElementDescription;

package/dist/ra-core/src/inference/inferTypeFromValues.js

@@ -0,0 +1,141 @@
+import getValuesFromRecords from './getValuesFromRecords';
+import { isObject, valuesAreArray, valuesAreBoolean, valuesAreDate, valuesAreDateString, valuesAreHtml, valuesAreInteger, valuesAreNumeric, valuesAreObject, valuesAreString, valuesAreUrl, valuesAreImageUrl, valuesAreEmail, } from './assertions';
+import { pluralize } from 'inflection';
+export const InferenceTypes = [
+    'array',
+    'boolean',
+    'date',
+    'email',
+    'id',
+    'image',
+    'number',
+    'reference',
+    'referenceChild',
+    'referenceArray',
+    'referenceArrayChild',
+    'richText',
+    'string',
+    'url',
+    'object',
+];
+/**
+ * Guesses an element type based on an array of values
+ *
+ * @example
+ *     inferElementFromValues(
+ *         'address',
+ *         ['2 Baker Street', '1 Downing street'],
+ *     );
+ *     // { type: 'string', props: { source: 'address' } }
+ *
+ * @param {string} name Property name, e.g. 'date_of_birth'
+ * @param {any[]} values an array of values from which to determine the type, e.g. [12, 34.4, 43]
+ */
+export const inferTypeFromValues = (name, values = []) => {
+    if (name === 'id') {
+        return { type: 'id', props: { source: name } };
+    }
+    if (name.substr(name.length - 3) === '_id') {
+        return {
+            type: 'reference',
+            props: {
+                source: name,
+                reference: pluralize(name.substr(0, name.length - 3)),
+            },
+            children: { type: 'referenceChild' },
+        };
+    }
+    if (name.substr(name.length - 2) === 'Id') {
+        return {
+            type: 'reference',
+            props: {
+                source: name,
+                reference: pluralize(name.substr(0, name.length - 2)),
+            },
+            children: { type: 'referenceChild' },
+        };
+    }
+    if (name.substr(name.length - 4) === '_ids') {
+        return {
+            type: 'referenceArray',
+            props: {
+                source: name,
+                reference: pluralize(name.substr(0, name.length - 4)),
+            },
+            children: { type: 'referenceArrayChild' },
+        };
+    }
+    if (name.substr(name.length - 3) === 'Ids') {
+        return {
+            type: 'referenceArray',
+            props: {
+                source: name,
+                reference: pluralize(name.substr(0, name.length - 3)),
+            },
+            children: { type: 'referenceArrayChild' },
+        };
+    }
+    if (values.length === 0) {
+        if (name === 'email') {
+            return { type: 'email', props: { source: name } };
+        }
+        if (name === 'url') {
+            return { type: 'url', props: { source: name } };
+        }
+        // FIXME introspect further using name
+        return { type: 'string', props: { source: name } };
+    }
+    if (valuesAreArray(values)) {
+        if (isObject(values[0][0])) {
+            const leafValues = getValuesFromRecords(values.reduce((acc, vals) => acc.concat(vals), []));
+            // FIXME bad visual representation
+            return {
+                type: 'array',
+                props: { source: name },
+                children: Object.keys(leafValues).map(leafName => inferTypeFromValues(leafName, leafValues[leafName])),
+            };
+        }
+        // FIXME introspect further
+        return { type: 'string', props: { source: name } };
+    }
+    if (valuesAreBoolean(values)) {
+        return { type: 'boolean', props: { source: name } };
+    }
+    if (valuesAreDate(values)) {
+        return { type: 'date', props: { source: name } };
+    }
+    if (valuesAreString(values)) {
+        if (name === 'email' || valuesAreEmail(values)) {
+            return { type: 'email', props: { source: name } };
+        }
+        if (name === 'url' || valuesAreUrl(values)) {
+            if (valuesAreImageUrl(values)) {
+                return { type: 'image', props: { source: name } };
+            }
+            return { type: 'url', props: { source: name } };
+        }
+        if (valuesAreDateString(values)) {
+            return { type: 'date', props: { source: name } };
+        }
+        if (valuesAreHtml(values)) {
+            return { type: 'richText', props: { source: name } };
+        }
+        if (valuesAreInteger(values) || valuesAreNumeric(values)) {
+            return { type: 'number', props: { source: name } };
+        }
+        return { type: 'string', props: { source: name } };
+    }
+    if (valuesAreInteger(values) || valuesAreNumeric(values)) {
+        return { type: 'number', props: { source: name } };
+    }
+    if (valuesAreObject(values)) {
+        /// Arbitrarily, choose the first prop of the first object
+        const propName = Object.keys(values[0]).shift();
+        if (!propName) {
+            return { type: 'object', props: { source: name } };
+        }
+        const leafValues = values.map(v => v[propName]);
+        return inferTypeFromValues(`${name}.${propName}`, leafValues);
+    }
+    return { type: 'string', props: { source: name } };
+};

package/dist/ra-core/src/inference/types.d.ts

@@ -0,0 +1,9 @@
+import { ComponentType } from 'react';
+export interface InferredType {
+    type?: ComponentType;
+    component?: ComponentType;
+    representation?: (props: any, children: any) => string;
+}
+export interface InferredTypeMap {
+    [key: string]: InferredType | undefined;
+}

package/dist/ra-core/src/inference/types.js

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

package/dist/ra-core/src/notification/CloseNotificationContext.d.ts

@@ -0,0 +1,2 @@
+export type CloseNotificationContextValue = () => void;
+export declare const CloseNotificationContext: import("react").Context<CloseNotificationContextValue | null>;

package/dist/ra-core/src/notification/CloseNotificationContext.js

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