@strato-admin/core 0.1.1 → 0.3.0

package/dist/ra-core/src/util/getFieldLabelTranslationArgs.js

@@ -0,0 +1,73 @@
+import { transform } from 'inflection';
+/**
+ * Returns an array of arguments to use with the translate function for the label of a field.
+ * The label will be computed from the resource and source props.
+ *
+ * Usage:
+ *  <span>
+ *      {translate(...getFieldLabelTranslationArgs({ label, resource, source }))}
+ *  </span>
+ *
+ * @see useTranslateLabel for a ready-to-use hook
+ */
+export const getFieldLabelTranslationArgs = (options) => {
+    if (!options)
+        return [''];
+    const { label, defaultLabel, resource, resourceFromContext, source } = options;
+    if (typeof label !== 'undefined')
+        return [label, { _: label }];
+    if (typeof source === 'undefined')
+        return [''];
+    const { sourceWithoutDigits, sourceSuffix } = getSourceParts(source);
+    const defaultLabelTranslation = transform(sourceSuffix.replace(/\./g, ' '), ['underscore', 'humanize']);
+    if (resource) {
+        return [
+            getResourceFieldLabelKey(resource, sourceWithoutDigits),
+            { _: defaultLabelTranslation },
+        ];
+    }
+    if (defaultLabel) {
+        return [defaultLabel, { _: defaultLabelTranslation }];
+    }
+    return [
+        getResourceFieldLabelKey(resourceFromContext || 'undefined', sourceWithoutDigits),
+        { _: defaultLabelTranslation },
+    ];
+};
+export default getFieldLabelTranslationArgs;
+export const getResourceFieldLabelKey = (resource, source) => `resources.${resource}.fields.${source}`;
+/**
+ * Uses the source string to guess a translation message and a default label.
+ *
+ * @example
+ * getSourceParts('pictures') // { sourceWithoutDigits: 'pictures', sourceSuffix: 'pictures' }
+ * getSourceParts('pictures.url') // { sourceWithoutDigits: 'pictures.url', sourceSuffix: 'pictures.url' }
+ * getSourceParts('pictures.0.url') // { sourceWithoutDigits: 'pictures.url', sourceSuffix: 'url' }
+ * getSourceParts('pictures.12.urls.5.protocol') // { sourceWithoutDigits: 'pictures.urls.protocol', sourceSuffix: 'protocol' }
+ */
+const getSourceParts = (source) => {
+    // remove digits, e.g. 'book.authors.2.categories.3.identifier.name' => 'book.authors.categories.identifier.name'
+    const sourceWithoutDigits = source.replace(/\.\d+\./g, '.');
+    // get final part, e.g. 'book.authors.2.categories.3.identifier.name' => 'identifier.name'
+    // we're not using a regexp here to avoid code scanning alert "Polynomial regular expression used on uncontrolled data"
+    const parts = source.split('.');
+    let lastPartWithDigits;
+    parts.forEach((part, index) => {
+        if (onlyDigits(part)) {
+            lastPartWithDigits = index;
+        }
+    });
+    const sourceSuffix = lastPartWithDigits != null
+        ? parts.slice(lastPartWithDigits + 1).join('.')
+        : source;
+    return { sourceWithoutDigits, sourceSuffix };
+};
+// 48 and 57 are the char codes for "0" and "9", respectively
+const onlyDigits = s => {
+    for (let i = s.length - 1; i >= 0; i--) {
+        const d = s.charCodeAt(i);
+        if (d < 48 || d > 57)
+            return false;
+    }
+    return true;
+};

package/dist/ra-core/src/util/getMutationMode.d.ts

@@ -0,0 +1 @@
+export declare const getMutationMode: (mutationMode: any, undoable: any) => any;

package/dist/ra-core/src/util/getMutationMode.js

@@ -0,0 +1,13 @@
+export const getMutationMode = (mutationMode, undoable) => {
+    if (mutationMode) {
+        return mutationMode;
+    }
+    switch (undoable) {
+        case true:
+            return 'undoable';
+        case false:
+            return 'pessimistic';
+        default:
+            return 'undoable';
+    }
+};

package/dist/ra-core/src/util/hooks.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @deprecated use `useState` instead, since React no longer
+ * issues warnings when calling setState on unmounted components.
+ */
+export declare function useSafeSetState<T>(initialState?: T | (() => T)): [T | undefined, React.Dispatch<React.SetStateAction<T>>];
+export declare function usePrevious<T>(value: T): T;
+export declare function useDeepCompareEffect(callback: any, inputs: any): void;
+/**
+ * A hook that returns true once a delay has expired.
+ * @param ms The delay in milliseconds
+ * @param key A key that can be used to reset the timer
+ * @returns true if the delay has expired, false otherwise
+ */
+export declare function useTimeout(ms?: number, key?: string): boolean;
+export declare function useIsMounted(): import("react").RefObject<boolean>;

package/dist/ra-core/src/util/hooks.js

@@ -0,0 +1,73 @@
+import { useRef, useEffect, useState, useCallback } from 'react';
+import isEqual from 'lodash/isEqual.js';
+// thanks Kent C Dodds for the following helpers
+/**
+ * @deprecated use `useState` instead, since React no longer
+ * issues warnings when calling setState on unmounted components.
+ */
+export function useSafeSetState(initialState) {
+    const [state, setState] = useState(initialState);
+    const mountedRef = useRef(false);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+        };
+    }, []);
+    const safeSetState = useCallback(args => {
+        if (mountedRef.current) {
+            return setState(args);
+        }
+    }, [mountedRef, setState]);
+    return [state, safeSetState];
+}
+export function usePrevious(value) {
+    const ref = useRef(null);
+    useEffect(() => {
+        ref.current = value;
+    });
+    return ref.current;
+}
+export function useDeepCompareEffect(callback, inputs) {
+    const cleanupRef = useRef(undefined);
+    useEffect(() => {
+        if (!isEqual(previousInputs, inputs)) {
+            cleanupRef.current = callback();
+        }
+        return () => {
+            if (typeof cleanupRef.current === 'function') {
+                cleanupRef.current();
+            }
+        };
+    });
+    const previousInputs = usePrevious(inputs);
+}
+/**
+ * A hook that returns true once a delay has expired.
+ * @param ms The delay in milliseconds
+ * @param key A key that can be used to reset the timer
+ * @returns true if the delay has expired, false otherwise
+ */
+export function useTimeout(ms = 0, key = '') {
+    const [ready, setReady] = useState(false);
+    useEffect(() => {
+        setReady(false);
+        const timer = setTimeout(() => {
+            setReady(true);
+        }, ms);
+        return () => {
+            clearTimeout(timer);
+        };
+    }, [key, ms, setReady]);
+    return ready;
+}
+export function useIsMounted() {
+    const isMounted = useRef(true);
+    useEffect(() => {
+        isMounted.current = true;
+        return () => {
+            isMounted.current = false;
+        };
+    }, []);
+    return isMounted;
+}

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

@@ -0,0 +1,20 @@
+import escapePath from './escapePath';
+import FieldTitle, { FieldTitleProps } from './FieldTitle';
+import removeEmpty from './removeEmpty';
+import removeKey from './removeKey';
+import Ready from './Ready';
+import warning from './warning';
+import useWhyDidYouUpdate from './useWhyDidYouUpdate';
+import { getMutationMode } from './getMutationMode';
+export * from './getFieldLabelTranslationArgs';
+export * from './mergeRefs';
+export * from './useEvent';
+export * from './useDebouncedEvent';
+export * from './useFieldValue';
+export { escapePath, FieldTitle, Ready, removeEmpty, removeKey, warning, useWhyDidYouUpdate, getMutationMode, };
+export type { FieldTitleProps };
+export * from './asyncDebounce';
+export * from './hooks';
+export * from './shallowEqual';
+export * from './useCheckForApplicationUpdate';
+export * from './genericMemo';

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

@@ -0,0 +1,19 @@
+import escapePath from './escapePath';
+import FieldTitle from './FieldTitle';
+import removeEmpty from './removeEmpty';
+import removeKey from './removeKey';
+import Ready from './Ready';
+import warning from './warning';
+import useWhyDidYouUpdate from './useWhyDidYouUpdate';
+import { getMutationMode } from './getMutationMode';
+export * from './getFieldLabelTranslationArgs';
+export * from './mergeRefs';
+export * from './useEvent';
+export * from './useDebouncedEvent';
+export * from './useFieldValue';
+export { escapePath, FieldTitle, Ready, removeEmpty, removeKey, warning, useWhyDidYouUpdate, getMutationMode, };
+export * from './asyncDebounce';
+export * from './hooks';
+export * from './shallowEqual';
+export * from './useCheckForApplicationUpdate';
+export * from './genericMemo';

package/dist/ra-core/src/util/mergeRefs.d.ts

@@ -0,0 +1,2 @@
+import { LegacyRef, MutableRefObject, RefCallback } from 'react';
+export declare function mergeRefs<T = any>(refs: Array<MutableRefObject<T> | LegacyRef<T>>): RefCallback<T>;

package/dist/ra-core/src/util/mergeRefs.js

@@ -0,0 +1,13 @@
+// https://github.com/gregberge/react-merge-refs
+export function mergeRefs(refs) {
+    return value => {
+        refs.forEach(ref => {
+            if (typeof ref === 'function') {
+                ref(value);
+            }
+            else if (ref != null) {
+                ref.current = value;
+            }
+        });
+    };
+}

package/dist/ra-core/src/util/removeEmpty.d.ts

@@ -0,0 +1,2 @@
+declare const removeEmpty: (object: any) => {};
+export default removeEmpty;

package/dist/ra-core/src/util/removeEmpty.js

@@ -0,0 +1,16 @@
+import { shallowEqual } from './shallowEqual';
+const isObject = obj => obj && Object.prototype.toString.call(obj) === '[object Object]';
+const isEmpty = obj => obj instanceof Date
+    ? false
+    : obj === '' ||
+        obj === null ||
+        obj === undefined ||
+        shallowEqual(obj, {});
+const removeEmpty = object => Object.keys(object).reduce((acc, key) => {
+    let child = object[key];
+    if (isObject(object[key])) {
+        child = removeEmpty(object[key]);
+    }
+    return isEmpty(child) ? acc : { ...acc, [key]: child };
+}, {});
+export default removeEmpty;

package/dist/ra-core/src/util/removeKey.d.ts

@@ -0,0 +1,2 @@
+declare const deepRemoveKey: (target: any, path: any) => any;
+export default deepRemoveKey;

package/dist/ra-core/src/util/removeKey.js

@@ -0,0 +1,22 @@
+const removeKey = (target, path) => Object.keys(target).reduce((acc, key) => {
+    if (key !== path) {
+        return Object.assign({}, acc, { [key]: target[key] });
+    }
+    return acc;
+}, {});
+const deepRemoveKey = (target, path) => {
+    const paths = path.split('.');
+    if (paths.length === 1) {
+        return removeKey(target, path);
+    }
+    const deepKey = paths[0];
+    if (target[deepKey] === undefined) {
+        return target;
+    }
+    const deep = deepRemoveKey(target[deepKey], paths.slice(1).join('.'));
+    if (Object.keys(deep).length === 0) {
+        return removeKey(target, deepKey);
+    }
+    return Object.assign({}, target, { [deepKey]: deep });
+};
+export default deepRemoveKey;

package/dist/ra-core/src/util/shallowEqual.d.ts

@@ -0,0 +1 @@
+export declare const shallowEqual: (objA: any, objB: any) => boolean;

package/dist/ra-core/src/util/shallowEqual.js

@@ -0,0 +1,29 @@
+function is(x, y) {
+    if (x === y) {
+        return x !== 0 || y !== 0 || 1 / x === 1 / y;
+    }
+    else {
+        return x !== x && y !== y;
+    }
+}
+export const shallowEqual = (objA, objB) => {
+    if (is(objA, objB))
+        return true;
+    if (typeof objA !== 'object' ||
+        objA === null ||
+        typeof objB !== 'object' ||
+        objB === null) {
+        return false;
+    }
+    const keysA = Object.keys(objA);
+    const keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length)
+        return false;
+    for (let i = 0; i < keysA.length; i++) {
+        if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) ||
+            !is(objA[keysA[i]], objB[keysA[i]])) {
+            return false;
+        }
+    }
+    return true;
+};

package/dist/ra-core/src/util/useCheckForApplicationUpdate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Checks if the application code has changed and calls the provided onNewVersionAvailable function when needed.
+ *
+ * It checks for code update by downloading the provided URL (default to the HTML page) and
+ * comparing the hash of the response with the hash of the current page.
+ *
+ * @param {UseCheckForApplicationUpdateOptions} options The options
+ * @param {Function} options.onNewVersionAvailable The function to call when a new version of the application is available.
+ * @param {string} options.url Optional. The URL to download to check for code update. Defaults to the current URL.
+ * @param {RequestInit} options.fetchOptions Optional. The options passed to fetch function when checking for update.
+ * @param {number} options.interval Optional. The interval in milliseconds between two checks. Defaults to 3600000 (1 hour).
+ * @param {boolean} options.disabled Optional. Whether the check should be disabled. Defaults to false.
+ */
+export declare const useCheckForApplicationUpdate: (options: UseCheckForApplicationUpdateOptions) => void;
+export interface UseCheckForApplicationUpdateOptions {
+    onNewVersionAvailable: () => void;
+    interval?: number;
+    url?: string;
+    fetchOptions?: RequestInit;
+    disabled?: boolean;
+}

package/dist/ra-core/src/util/useCheckForApplicationUpdate.js

@@ -0,0 +1,84 @@
+import { useEffect, useRef } from 'react';
+import { useEvent } from './useEvent';
+/**
+ * Checks if the application code has changed and calls the provided onNewVersionAvailable function when needed.
+ *
+ * It checks for code update by downloading the provided URL (default to the HTML page) and
+ * comparing the hash of the response with the hash of the current page.
+ *
+ * @param {UseCheckForApplicationUpdateOptions} options The options
+ * @param {Function} options.onNewVersionAvailable The function to call when a new version of the application is available.
+ * @param {string} options.url Optional. The URL to download to check for code update. Defaults to the current URL.
+ * @param {RequestInit} options.fetchOptions Optional. The options passed to fetch function when checking for update.
+ * @param {number} options.interval Optional. The interval in milliseconds between two checks. Defaults to 3600000 (1 hour).
+ * @param {boolean} options.disabled Optional. Whether the check should be disabled. Defaults to false.
+ */
+export const useCheckForApplicationUpdate = (options) => {
+    const { url = window.location.href, fetchOptions, interval: delay = ONE_HOUR, onNewVersionAvailable: onNewVersionAvailableProp, disabled = process.env.NODE_ENV !== 'production', } = options;
+    const currentHash = useRef(undefined);
+    const onNewVersionAvailable = useEvent(onNewVersionAvailableProp);
+    useEffect(() => {
+        if (disabled)
+            return;
+        getHashForUrl(url, fetchOptions).then(hash => {
+            if (hash != null) {
+                currentHash.current = hash;
+            }
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [disabled, url, JSON.stringify(fetchOptions)]);
+    useEffect(() => {
+        if (disabled)
+            return;
+        const interval = setInterval(() => {
+            getHashForUrl(url, fetchOptions)
+                .then(hash => {
+                if (hash != null && currentHash.current !== hash) {
+                    // Store the latest hash to avoid calling the onNewVersionAvailable function multiple times
+                    // or when users have closed the notification
+                    currentHash.current = hash;
+                    onNewVersionAvailable();
+                }
+            })
+                .catch(() => {
+                // Ignore errors to avoid issues when connectivity is lost
+            });
+        }, delay);
+        return () => clearInterval(interval);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        delay,
+        onNewVersionAvailable,
+        disabled,
+        url,
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        JSON.stringify(fetchOptions),
+    ]);
+};
+const getHashForUrl = async (url, fetchOptions) => {
+    try {
+        const response = await fetch(url, fetchOptions);
+        if (!response.ok)
+            return null;
+        const text = await response.text();
+        return hash(text);
+    }
+    catch (e) {
+        return null;
+    }
+};
+// Simple hash function, taken from https://stackoverflow.com/a/52171480/3723993, suggested by Copilot
+const hash = (value, seed = 0) => {
+    let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
+    for (let i = 0, ch; i < value.length; i++) {
+        ch = value.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, 2654435761);
+        h2 = Math.imul(h2 ^ ch, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
+    h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
+    h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+};
+const ONE_HOUR = 1000 * 60 * 60;

package/dist/ra-core/src/util/useDebouncedEvent.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hook somewhat equivalent to useEvent, but with a debounce
+ * Returns a debounced callback which will not change across re-renders unless the
+ * callback or delay changes
+ * @see https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-from-usecallback
+ * @see https://github.com/facebook/react/issues/14099#issuecomment-440013892
+ */
+export declare const useDebouncedEvent: <Args extends unknown[], Return>(callback: (...args: Args) => Return, delay: number) => (...args: Args) => Return | undefined;

package/dist/ra-core/src/util/useDebouncedEvent.js

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { useCallback, useRef } from 'react';
+import debounce from 'lodash/debounce.js';
+import { useEvent } from './useEvent';
+// allow the hook to work in SSR
+const useLayoutEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;
+/**
+ * Hook somewhat equivalent to useEvent, but with a debounce
+ * Returns a debounced callback which will not change across re-renders unless the
+ * callback or delay changes
+ * @see https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-from-usecallback
+ * @see https://github.com/facebook/react/issues/14099#issuecomment-440013892
+ */
+export const useDebouncedEvent = (callback, delay) => {
+    // Create a ref that stores the debounced callback
+    const debouncedCallbackRef = useRef(() => {
+        throw new Error('Cannot call an event handler while rendering.');
+    });
+    // Keep a stable ref to the callback (in case it's an inline function for instance)
+    const stableCallback = useEvent(callback);
+    // Whenever callback or delay changes, we need to update the debounced callback
+    useLayoutEffect(() => {
+        debouncedCallbackRef.current = debounce(stableCallback, delay);
+    }, [stableCallback, delay]);
+    // The function returned by useCallback will invoke the debounced callback
+    // Its dependencies array is empty, so it never changes across re-renders
+    return useCallback((...args) => debouncedCallbackRef.current(...args), []);
+};

package/dist/ra-core/src/util/useEvent.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Alternative to useCallback that doesn't update the callback when dependencies change
+ *
+ * @see https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-from-usecallback
+ * @see https://github.com/facebook/react/issues/14099#issuecomment-440013892
+ */
+export declare const useEvent: <Args extends unknown[], Return>(fn: (...args: Args) => Return) => ((...args: Args) => Return);

package/dist/ra-core/src/util/useEvent.js

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { useCallback } from 'react';
+// allow the hook to work in SSR
+const useLayoutEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;
+/**
+ * Alternative to useCallback that doesn't update the callback when dependencies change
+ *
+ * @see https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-from-usecallback
+ * @see https://github.com/facebook/react/issues/14099#issuecomment-440013892
+ */
+export const useEvent = (fn) => {
+    const ref = React.useRef(() => {
+        throw new Error('Cannot call an event handler while rendering.');
+    });
+    useLayoutEffect(() => {
+        ref.current = fn;
+    });
+    return useCallback((...args) => ref.current(...args), []);
+};

package/dist/ra-core/src/util/useFieldValue.d.ts

@@ -0,0 +1,21 @@
+import { ExtractRecordPaths } from '../types';
+/**
+ * A hook that gets the value of a field of the current record.
+ * @param params The hook parameters
+ * @param params.source The field source
+ * @param params.record The record to use. Uses the record from the RecordContext if not provided
+ * @param params.defaultValue The value to return when the field value is empty
+ * @returns The field value
+ *
+ * @example
+ * const MyField = (props: { source: string }) => {
+ *   const value = useFieldValue(props);
+ *   return <span>{value}</span>;
+ * }
+ */
+export declare const useFieldValue: <RecordType extends Record<string, any> = Record<string, any>>(params: UseFieldValueOptions<RecordType>) => any;
+export interface UseFieldValueOptions<RecordType extends Record<string, any> = Record<string, any>> {
+    defaultValue?: any;
+    source: ExtractRecordPaths<RecordType>;
+    record?: RecordType;
+}

package/dist/ra-core/src/util/useFieldValue.js

@@ -0,0 +1,27 @@
+import get from 'lodash/get.js';
+import { useRecordContext } from '../controller';
+/**
+ * A hook that gets the value of a field of the current record.
+ * @param params The hook parameters
+ * @param params.source The field source
+ * @param params.record The record to use. Uses the record from the RecordContext if not provided
+ * @param params.defaultValue The value to return when the field value is empty
+ * @returns The field value
+ *
+ * @example
+ * const MyField = (props: { source: string }) => {
+ *   const value = useFieldValue(props);
+ *   return <span>{value}</span>;
+ * }
+ */
+export const useFieldValue = (params) => {
+    const { defaultValue, source } = params;
+    // We use the record from the RecordContext and do not rely on the SourceContext on purpose to
+    // avoid having the wrong source targeting the record.
+    // Indeed, some components may create a sub record context (SimpleFormIterator, TranslatableInputs, etc.). In this case,
+    // it they used the SourceContext as well, they would have the wrong source.
+    // Inputs needs the SourceContext as they rely on the Form value and you can't have nested forms.
+    // Fields needs the RecordContext as they rely on the Record value and you can have nested RecordContext.
+    const record = useRecordContext(params);
+    return get(record, source, defaultValue);
+};

package/dist/ra-core/src/util/useWhyDidYouUpdate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Debug hook showing which props updated between two renders
+ * @example
+ *
+ * const MyComponent = React.memo(props => {
+ *   useWhyDidYouUpdate('MyComponent', props);
+ *   return <div...;
+ * });
+ *
+ * @link https://usehooks.com/useWhyDidYouUpdate/
+ */
+export default function useWhyDidYouUpdate(name: any, props: any): void;

package/dist/ra-core/src/util/useWhyDidYouUpdate.js

@@ -0,0 +1,42 @@
+import { useRef, useEffect } from 'react';
+/**
+ * Debug hook showing which props updated between two renders
+ * @example
+ *
+ * const MyComponent = React.memo(props => {
+ *   useWhyDidYouUpdate('MyComponent', props);
+ *   return <div...;
+ * });
+ *
+ * @link https://usehooks.com/useWhyDidYouUpdate/
+ */
+export default function useWhyDidYouUpdate(name, props) {
+    // Get a mutable ref object where we can store props ...
+    // ... for comparison next time this hook runs.
+    const previousProps = useRef(null);
+    useEffect(() => {
+        if (previousProps.current) {
+            // Get all keys from previous and current props
+            const allKeys = Object.keys({ ...previousProps.current, ...props });
+            // Use this object to keep track of changed props
+            const changesObj = {};
+            // Iterate through keys
+            allKeys.forEach(key => {
+                // If previous is different from current
+                if (previousProps.current[key] !== props[key]) {
+                    // Add to changesObj
+                    changesObj[key] = {
+                        from: previousProps.current[key],
+                        to: props[key],
+                    };
+                }
+            });
+            // If changesObj not empty then output to console
+            if (Object.keys(changesObj).length) {
+                console.log('[why-did-you-update]', name, changesObj);
+            }
+        }
+        // Finally update previousProps with current props for next hook call
+        previousProps.current = props;
+    });
+}

package/dist/ra-core/src/util/warning.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (condition: any, message: string) => void;
+export default _default;

package/dist/ra-core/src/util/warning.js

@@ -0,0 +1,5 @@
+export default (condition, message) => {
+    if (condition && process.env.NODE_ENV !== 'production') {
+        console.warn(message);
+    }
+};

package/dist/resource/Resource.d.ts

@@ -0,0 +1,14 @@
+import { ResourceProps } from '@strato-admin/ra-core';
+/**
+ * Strato version of Resource that implements the new routing scheme:
+ * - Edit: /:id/edit
+ * - Detail (Show): /:id (no suffix)
+ *
+ * This allows for nested resources to be defined under /:id/:subresource
+ * without conflicting with the standard 'show' action.
+ */
+export declare const Resource: {
+    (props: ResourceProps): import("react/jsx-runtime").JSX.Element;
+    raName: string;
+    registerResource: any;
+};