@hitachivantara/uikit-react-core 5.103.0 → 5.104.0

package/dist/esm/packages/core/src/TreeView/internals/hooks/useInstanceEventHandler.js

@@ -0,0 +1,77 @@
+import * as a from "react";
+import { FinalizationRegistryBasedCleanupTracking } from "../utils/FinalizationRegistryBasedCleanupTracking.js";
+import { TimerBasedCleanupTracking } from "../utils/TimerBasedCleanupTracking.js";
+class ObjectToBeRetainedByReact {
+}
+function createUseInstanceEventHandler(registryContainer2) {
+  let cleanupTokensCounter = 0;
+  return function useInstanceEventHandler2(instance, eventName, handler) {
+    if (registryContainer2.registry === null) {
+      registryContainer2.registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistryBasedCleanupTracking() : new TimerBasedCleanupTracking();
+    }
+    const [objectRetainedByReact] = a.useState(
+      new ObjectToBeRetainedByReact()
+    );
+    const subscription = a.useRef(null);
+    const handlerRef = a.useRef(void 0);
+    handlerRef.current = handler;
+    const cleanupTokenRef = a.useRef(null);
+    if (!subscription.current && handlerRef.current) {
+      const enhancedHandler = (params, event) => {
+        if (!event.defaultMuiPrevented) {
+          handlerRef.current?.(params, event);
+        }
+      };
+      subscription.current = instance.$$subscribeEvent(
+        eventName,
+        enhancedHandler
+      );
+      cleanupTokensCounter += 1;
+      cleanupTokenRef.current = { cleanupToken: cleanupTokensCounter };
+      registryContainer2.registry.register(
+        objectRetainedByReact,
+        // The callback below will be called once this reference stops being retained
+        () => {
+          subscription.current?.();
+          subscription.current = null;
+          cleanupTokenRef.current = null;
+        },
+        cleanupTokenRef.current
+      );
+    } else if (!handlerRef.current && subscription.current) {
+      subscription.current();
+      subscription.current = null;
+      if (cleanupTokenRef.current) {
+        registryContainer2.registry.unregister(cleanupTokenRef.current);
+        cleanupTokenRef.current = null;
+      }
+    }
+    a.useEffect(() => {
+      if (!subscription.current && handlerRef.current) {
+        const enhancedHandler = (params, event) => {
+          if (!event.defaultMuiPrevented) {
+            handlerRef.current?.(params, event);
+          }
+        };
+        subscription.current = instance.$$subscribeEvent(
+          eventName,
+          enhancedHandler
+        );
+      }
+      if (cleanupTokenRef.current && registryContainer2.registry) {
+        registryContainer2.registry.unregister(cleanupTokenRef.current);
+        cleanupTokenRef.current = null;
+      }
+      return () => {
+        subscription.current?.();
+        subscription.current = null;
+      };
+    }, [instance, eventName]);
+  };
+}
+const registryContainer = { registry: null };
+const useInstanceEventHandler = createUseInstanceEventHandler(registryContainer);
+export {
+  createUseInstanceEventHandler,
+  useInstanceEventHandler
+};

package/dist/esm/packages/core/src/TreeView/internals/hooks/useTreeView.js

@@ -0,0 +1,73 @@
+import * as a from "react";
+import { useForkRef } from "@mui/material/utils";
+import { TREE_VIEW_CORE_PLUGINS } from "../corePlugins.js";
+import { DEFAULT_TREE_VIEW_CONTEXT_VALUE } from "../TreeViewProvider.js";
+import { useTreeViewModels } from "./useTreeViewModels.js";
+const useTreeView = (inParams) => {
+  const plugins = [...TREE_VIEW_CORE_PLUGINS, ...inParams.plugins];
+  const params = plugins.reduce((acc, plugin) => {
+    if (plugin.getDefaultizedParams) {
+      return plugin.getDefaultizedParams(acc);
+    }
+    return acc;
+  }, inParams);
+  const models = useTreeViewModels(
+    plugins,
+    params
+  );
+  const instanceRef = a.useRef(
+    {}
+  );
+  const instance = instanceRef.current;
+  const innerRootRef = a.useRef(null);
+  const handleRootRef = useForkRef(innerRootRef, inParams.rootRef);
+  const [state, setState] = a.useState(() => {
+    const temp = {};
+    plugins.forEach((plugin) => {
+      if (plugin.getInitialState) {
+        Object.assign(
+          temp,
+          plugin.getInitialState(
+            params
+          )
+        );
+      }
+    });
+    return temp;
+  });
+  const rootPropsGetters = [];
+  let contextValue = DEFAULT_TREE_VIEW_CONTEXT_VALUE;
+  const runPlugin = (plugin) => {
+    const pluginResponse = plugin({
+      instance,
+      params,
+      state,
+      setState,
+      rootRef: innerRootRef,
+      models
+    }) || {};
+    if (pluginResponse.getRootProps) {
+      rootPropsGetters.push(pluginResponse.getRootProps);
+    }
+    if (pluginResponse.contextValue) {
+      contextValue = pluginResponse.contextValue;
+    }
+  };
+  plugins.forEach(runPlugin);
+  const getRootProps = (otherHandlers = {}) => {
+    const rootProps = {
+      role: "tree",
+      tabIndex: 0,
+      ...otherHandlers,
+      ref: handleRootRef
+    };
+    rootPropsGetters.forEach((rootPropsGetter) => {
+      Object.assign(rootProps, rootPropsGetter(otherHandlers));
+    });
+    return rootProps;
+  };
+  return { getRootProps, rootRef: handleRootRef, contextValue };
+};
+export {
+  useTreeView
+};

package/dist/esm/packages/core/src/TreeView/internals/hooks/useTreeViewInstanceEvents.js

@@ -0,0 +1,36 @@
+import * as a from "react";
+import { EventManager } from "../utils/EventManager.js";
+import { populateInstance } from "./utils.js";
+const isSyntheticEvent = (event) => {
+  return event.isPropagationStopped !== void 0;
+};
+const useTreeViewInstanceEvents = ({ instance }) => {
+  const [eventManager] = a.useState(() => new EventManager());
+  const publishEvent = a.useCallback(
+    (...args) => {
+      const [name, params, event = {}] = args;
+      event.defaultMuiPrevented = false;
+      if (isSyntheticEvent(event) && event.isPropagationStopped()) {
+        return;
+      }
+      eventManager.emit(name, params, event);
+    },
+    [eventManager]
+  );
+  const subscribeEvent = a.useCallback(
+    (event, handler) => {
+      eventManager.on(event, handler);
+      return () => {
+        eventManager.removeListener(event, handler);
+      };
+    },
+    [eventManager]
+  );
+  populateInstance(instance, {
+    $$publishEvent: publishEvent,
+    $$subscribeEvent: subscribeEvent
+  });
+};
+export {
+  useTreeViewInstanceEvents
+};

package/dist/esm/packages/core/src/TreeView/internals/hooks/useTreeViewModels.js

@@ -0,0 +1,43 @@
+import * as a from "react";
+const useTreeViewModels = (plugins, props) => {
+  const modelsRef = a.useRef({});
+  const [modelsState, setModelsState] = a.useState(() => {
+    const initialState = {};
+    plugins.forEach((plugin) => {
+      if (plugin.models) {
+        Object.entries(plugin.models).forEach(([modelName, model]) => {
+          modelsRef.current[modelName] = {
+            controlledProp: model.controlledProp,
+            defaultProp: model.defaultProp,
+            isControlled: props[model.controlledProp] !== void 0
+          };
+          initialState[modelName] = props[model.defaultProp];
+        });
+      }
+    });
+    return initialState;
+  });
+  const models = Object.fromEntries(
+    Object.entries(modelsRef.current).map(([modelName, model]) => {
+      const value = model.isControlled ? props[model.controlledProp] : modelsState[modelName];
+      return [
+        modelName,
+        {
+          value,
+          setValue: (newValue) => {
+            if (!model.isControlled) {
+              setModelsState((prevState) => ({
+                ...prevState,
+                [modelName]: newValue
+              }));
+            }
+          }
+        }
+      ];
+    })
+  );
+  return models;
+};
+export {
+  useTreeViewModels
+};

package/dist/esm/packages/core/src/hooks/useUniqueId.js

@@ -0,0 +1,14 @@
+import * as a from "react";
+import { useEnhancedEffect } from "./useEnhancedEffect.js";
+const useReactId = a["useId".toString()] || (() => void 0);
+let count = 0;
+const useUniqueId = (deterministicId, idPrefix) => {
+  const [id, setId] = a.useState(useReactId());
+  useEnhancedEffect(() => {
+    if (!deterministicId) setId((reactId) => reactId ?? String(count++));
+  }, [deterministicId, idPrefix]);
+  return deterministicId || (idPrefix ? idPrefix + id : id ?? "");
+};
+export {
+  useUniqueId
+};