@applica-software-guru/react-admin 1.3.151 → 1.3.153

package/src/hooks/useLocalizedValue.tsx

@@ -0,0 +1,34 @@
+import { useLocaleState } from 'ra-core';
+import { IGetLocalizedValueOptions, ILocalizedValue, getLocalizedValue } from '../utils';
+import { useCallback } from 'react';
+
+function useLocale(locale?: string): string {
+  const [defaultLocale] = useLocaleState();
+
+  return locale !== undefined ? String(locale) : defaultLocale;
+}
+
+type IUseLocalizeValueOptions = IGetLocalizedValueOptions & {
+  locale?: string;
+};
+function useLocalizedValue<T>(value: ILocalizedValue<T>, options?: IUseLocalizeValueOptions): T | undefined {
+  const language = useLocale(options?.locale),
+    localizedValue = getLocalizedValue<T>(value, language, options);
+
+  return localizedValue;
+}
+
+type IUseGetLocalizeValueOptions = IUseLocalizeValueOptions;
+function useGetLocalizedValue<T>(options?: IUseGetLocalizeValueOptions): (v: ILocalizedValue<T>) => T | undefined {
+  const language = useLocale(options?.locale),
+    callback = useCallback(
+      (value: ILocalizedValue<T>) => {
+        return getLocalizedValue<T>(value, language, options);
+      },
+      [language, options]
+    );
+
+  return callback;
+}
+
+export { useLocalizedValue, useGetLocalizedValue };

package/src/hooks/usePopoverState.tsx

@@ -0,0 +1,28 @@
+import { MouseEvent, useCallback, useState } from 'react';
+
+function usePopoverState() {
+  const [anchorEl, setAnchorEl] = useState<HTMLElement | null>(null),
+    open = Boolean(anchorEl),
+    handleClick = useCallback((e: MouseEvent<HTMLElement>) => setAnchorEl(e?.currentTarget), [setAnchorEl]),
+    handleClose = useCallback(() => setAnchorEl(null), [setAnchorEl]),
+    handleToggle = useCallback(
+      (e: MouseEvent<HTMLElement>) => {
+        if (!open) {
+          handleClick(e);
+        } else {
+          handleClose();
+        }
+      },
+      [open, handleClick, handleClose]
+    );
+
+  return {
+    anchorEl: anchorEl,
+    open: open,
+    handleClick: handleClick,
+    handleClose: handleClose,
+    handleToggle: handleToggle
+  };
+}
+
+export { usePopoverState };

package/src/utils/localizedValue.ts

@@ -1,9 +1,13 @@
 import _ from 'lodash';
+type ILocale = {
+  name: string;
+  locale: string;
+};
 type ILocalizedValue<T> = { [key: string]: T };
 
 function localizedValueHasAllLocales<T>(
   value: ILocalizedValue<T> = {},
-  locales: Array<{ name: string; locale: string }> = [],
+  locales: Array<ILocale> = [],
   options: { isEmpty?: (v: T) => boolean } = {}
 ): boolean {
   const { isEmpty = _.isEmpty } = options;
@@ -11,4 +15,35 @@ function localizedValueHasAllLocales<T>(
   return !_.some(locales, (l) => isEmpty((value ?? {})[l.locale]));
 }
 
-export { localizedValueHasAllLocales };
+type IGetLocalizedValueOptions = {
+  fallback?: boolean;
+  fallbackLocales?: Array<string>;
+};
+function getLocalizedValue<T>(value: ILocalizedValue<T>, locale: string, options?: IGetLocalizedValueOptions): T | undefined {
+  if (!_.isPlainObject(value) || locale === undefined) {
+    return undefined;
+  }
+
+  const _options: IGetLocalizedValueOptions = _.isPlainObject(options) ? (options as IGetLocalizedValueOptions) : {},
+    fallback = Boolean(_options?.fallback ?? true);
+
+  let localizedValue: T | undefined = value[String(locale)];
+
+  if (localizedValue === undefined && fallback) {
+    const fallbackLocales = _.isArray(_options.fallbackLocales) && !_.isEmpty(_options.fallbackLocales) ? _options.fallbackLocales : ['en'];
+    localizedValue = _.chain(fallbackLocales)
+      .map((l) => value[String(l)])
+      .reject(_.isUndefined)
+      .first()
+      .value() as T | undefined;
+
+    if (localizedValue === undefined) {
+      localizedValue = _.chain(value).values().first().value() as T | undefined;
+    }
+  }
+
+  return localizedValue;
+}
+
+export type { ILocalizedValue, IGetLocalizedValueOptions };
+export { localizedValueHasAllLocales, getLocalizedValue };