@hitachivantara/uikit-react-core 6.8.2 → 6.9.0

package/dist/TreeView/internals/hooks/useTreeViewInstanceEvents.js

@@ -1,36 +1,31 @@
-import * as React 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] = React.useState(() => new EventManager());
-  const publishEvent = React.useCallback(
-    (...args) => {
-      const [name, params, event = {}] = args;
-      event.defaultMuiPrevented = false;
-      if (isSyntheticEvent(event) && event.isPropagationStopped()) {
-        return;
-      }
-      eventManager.emit(name, params, event);
-    },
-    [eventManager]
-  );
-  const subscribeEvent = React.useCallback(
-    (event, handler) => {
-      eventManager.on(event, handler);
-      return () => {
-        eventManager.removeListener(event, handler);
-      };
-    },
-    [eventManager]
-  );
-  populateInstance(instance, {
-    $$publishEvent: publishEvent,
-    $$subscribeEvent: subscribeEvent
-  });
+import { EventManager } from "../utils/EventManager.js";
+import * as React from "react";
+//#region src/TreeView/internals/hooks/useTreeViewInstanceEvents.ts
+var isSyntheticEvent = (event) => {
+	return event.isPropagationStopped !== void 0;
 };
-export {
-  useTreeViewInstanceEvents
+/**
+* Plugin responsible for the registration of the nodes defined as JSX children of the TreeView.
+* When we will have both a SimpleTreeView using JSX children and a TreeView using a data prop,
+* this plugin will only be used by SimpleTreeView.
+*/
+var useTreeViewInstanceEvents = ({ instance }) => {
+	const [eventManager] = React.useState(() => new EventManager());
+	populateInstance(instance, {
+		$$publishEvent: React.useCallback((...args) => {
+			const [name, params, event = {}] = args;
+			event.defaultMuiPrevented = false;
+			if (isSyntheticEvent(event) && event.isPropagationStopped()) return;
+			eventManager.emit(name, params, event);
+		}, [eventManager]),
+		$$subscribeEvent: React.useCallback((event, handler) => {
+			eventManager.on(event, handler);
+			return () => {
+				eventManager.removeListener(event, handler);
+			};
+		}, [eventManager])
+	});
 };
+//#endregion
+export { useTreeViewInstanceEvents };

package/dist/TreeView/internals/hooks/useTreeViewModels.js

@@ -1,45 +1,36 @@
 import * as React from "react";
-const useTreeViewModels = (plugins, props) => {
-  const modelsRef = React.useRef({});
-  const [modelsState, setModelsState] = React.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
+//#region src/TreeView/internals/hooks/useTreeViewModels.ts
+/**
+* Implements the same behavior as `useControlled` but for several models.
+* The controlled models are never stored in the state and the state is only updated if the model is not controlled.
+*/
+var useTreeViewModels = (plugins, props) => {
+	const modelsRef = React.useRef({});
+	const [modelsState, setModelsState] = React.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;
+	});
+	return Object.fromEntries(Object.entries(modelsRef.current).map(([modelName, model]) => {
+		return [modelName, {
+			value: model.isControlled ? props[model.controlledProp] : modelsState[modelName],
+			setValue: (newValue) => {
+				if (!model.isControlled) setModelsState((prevState) => ({
+					...prevState,
+					[modelName]: newValue
+				}));
+			}
+		}];
+	}));
 };
+//#endregion
+export { useTreeViewModels };

package/dist/TreeView/internals/hooks/utils.js

@@ -1,46 +1,32 @@
-const getPreviousNode = (instance, nodeId) => {
-  const node = instance.getNode(nodeId);
-  const siblings = instance.getNavigableChildrenIds(node.parentId);
-  const nodeIndex = siblings.indexOf(nodeId);
-  if (nodeIndex === 0) {
-    return node.parentId;
-  }
-  let currentNode = siblings[nodeIndex - 1];
-  while (instance.isNodeExpanded(currentNode) && instance.getNavigableChildrenIds(currentNode).length > 0) {
-    currentNode = instance.getNavigableChildrenIds(currentNode).pop();
-  }
-  return currentNode;
+//#region src/TreeView/internals/hooks/utils.ts
+var getPreviousNode = (instance, nodeId) => {
+	const node = instance.getNode(nodeId);
+	const siblings = instance.getNavigableChildrenIds(node.parentId);
+	const nodeIndex = siblings.indexOf(nodeId);
+	if (nodeIndex === 0) return node.parentId;
+	let currentNode = siblings[nodeIndex - 1];
+	while (instance.isNodeExpanded(currentNode) && instance.getNavigableChildrenIds(currentNode).length > 0) currentNode = instance.getNavigableChildrenIds(currentNode).pop();
+	return currentNode;
 };
-const getNextNode = (instance, nodeId) => {
-  if (instance.isNodeExpanded(nodeId) && instance.getNavigableChildrenIds(nodeId).length > 0) {
-    return instance.getNavigableChildrenIds(nodeId)[0];
-  }
-  let node = instance.getNode(nodeId);
-  while (node != null) {
-    const siblings = instance.getNavigableChildrenIds(node.parentId);
-    const nextSibling = siblings[siblings.indexOf(node.id) + 1];
-    if (nextSibling) {
-      return nextSibling;
-    }
-    node = instance.getNode(node.parentId);
-  }
-  return null;
+var getNextNode = (instance, nodeId) => {
+	if (instance.isNodeExpanded(nodeId) && instance.getNavigableChildrenIds(nodeId).length > 0) return instance.getNavigableChildrenIds(nodeId)[0];
+	let node = instance.getNode(nodeId);
+	while (node != null) {
+		const siblings = instance.getNavigableChildrenIds(node.parentId);
+		const nextSibling = siblings[siblings.indexOf(node.id) + 1];
+		if (nextSibling) return nextSibling;
+		node = instance.getNode(node.parentId);
+	}
+	return null;
 };
-const getLastNode = (instance) => {
-  let lastNode = instance.getNavigableChildrenIds(null).pop();
-  while (instance.isNodeExpanded(lastNode)) {
-    lastNode = instance.getNavigableChildrenIds(lastNode).pop();
-  }
-  return lastNode;
+var getLastNode = (instance) => {
+	let lastNode = instance.getNavigableChildrenIds(null).pop();
+	while (instance.isNodeExpanded(lastNode)) lastNode = instance.getNavigableChildrenIds(lastNode).pop();
+	return lastNode;
 };
-const getFirstNode = (instance) => instance.getNavigableChildrenIds(null)[0];
-const populateInstance = (instance, methods) => {
-  Object.assign(instance, methods);
-};
-export {
-  getFirstNode,
-  getLastNode,
-  getNextNode,
-  getPreviousNode,
-  populateInstance
+var getFirstNode = (instance) => instance.getNavigableChildrenIds(null)[0];
+var populateInstance = (instance, methods) => {
+	Object.assign(instance, methods);
 };
+//#endregion
+export { getFirstNode, getLastNode, getNextNode, getPreviousNode, populateInstance };

package/dist/TreeView/internals/utils/EventManager.js

@@ -1,59 +1,50 @@
-class EventManager {
-  maxListeners = 20;
-  warnOnce = false;
-  events = {};
-  on(eventName, listener, options = {}) {
-    let collection = this.events[eventName];
-    if (!collection) {
-      collection = {
-        highPriority: /* @__PURE__ */ new Map(),
-        regular: /* @__PURE__ */ new Map()
-      };
-      this.events[eventName] = collection;
-    }
-    if (options.isFirst) {
-      collection.highPriority.set(listener, true);
-    } else {
-      collection.regular.set(listener, true);
-    }
-  }
-  removeListener(eventName, listener) {
-    if (this.events[eventName]) {
-      this.events[eventName].regular.delete(listener);
-      this.events[eventName].highPriority.delete(listener);
-    }
-  }
-  removeAllListeners() {
-    this.events = {};
-  }
-  emit(eventName, ...args) {
-    const collection = this.events[eventName];
-    if (!collection) {
-      return;
-    }
-    const highPriorityListeners = Array.from(collection.highPriority.keys());
-    const regularListeners = Array.from(collection.regular.keys());
-    for (let i = highPriorityListeners.length - 1; i >= 0; i -= 1) {
-      const listener = highPriorityListeners[i];
-      if (collection.highPriority.has(listener)) {
-        listener.apply(this, args);
-      }
-    }
-    for (let i = 0; i < regularListeners.length; i += 1) {
-      const listener = regularListeners[i];
-      if (collection.regular.has(listener)) {
-        listener.apply(this, args);
-      }
-    }
-  }
-  once(eventName, listener) {
-    const that = this;
-    this.on(eventName, function oneTimeListener(...args) {
-      that.removeListener(eventName, oneTimeListener);
-      listener.apply(that, args);
-    });
-  }
-}
-export {
-  EventManager
+//#region src/TreeView/internals/utils/EventManager.ts
+var EventManager = class {
+	maxListeners = 20;
+	warnOnce = false;
+	events = {};
+	on(eventName, listener, options = {}) {
+		let collection = this.events[eventName];
+		if (!collection) {
+			collection = {
+				highPriority: /* @__PURE__ */ new Map(),
+				regular: /* @__PURE__ */ new Map()
+			};
+			this.events[eventName] = collection;
+		}
+		if (options.isFirst) collection.highPriority.set(listener, true);
+		else collection.regular.set(listener, true);
+	}
+	removeListener(eventName, listener) {
+		if (this.events[eventName]) {
+			this.events[eventName].regular.delete(listener);
+			this.events[eventName].highPriority.delete(listener);
+		}
+	}
+	removeAllListeners() {
+		this.events = {};
+	}
+	emit(eventName, ...args) {
+		const collection = this.events[eventName];
+		if (!collection) return;
+		const highPriorityListeners = Array.from(collection.highPriority.keys());
+		const regularListeners = Array.from(collection.regular.keys());
+		for (let i = highPriorityListeners.length - 1; i >= 0; i -= 1) {
+			const listener = highPriorityListeners[i];
+			if (collection.highPriority.has(listener)) listener.apply(this, args);
+		}
+		for (let i = 0; i < regularListeners.length; i += 1) {
+			const listener = regularListeners[i];
+			if (collection.regular.has(listener)) listener.apply(this, args);
+		}
+	}
+	once(eventName, listener) {
+		const that = this;
+		this.on(eventName, function oneTimeListener(...args) {
+			that.removeListener(eventName, oneTimeListener);
+			listener.apply(that, args);
+		});
+	}
 };
+//#endregion
+export { EventManager };

package/dist/TreeView/internals/utils/FinalizationRegistryBasedCleanupTracking.js

@@ -1,19 +1,15 @@
-class FinalizationRegistryBasedCleanupTracking {
-  registry = new FinalizationRegistry((unsubscribe) => {
-    if (typeof unsubscribe === "function") {
-      unsubscribe();
-    }
-  });
-  register(object, unsubscribe, unregisterToken) {
-    this.registry.register(object, unsubscribe, unregisterToken);
-  }
-  unregister(unregisterToken) {
-    this.registry.unregister(unregisterToken);
-  }
-  // eslint-disable-next-line class-methods-use-this
-  reset() {
-  }
-}
-export {
-  FinalizationRegistryBasedCleanupTracking
+//#region src/TreeView/internals/utils/FinalizationRegistryBasedCleanupTracking.ts
+var FinalizationRegistryBasedCleanupTracking = class {
+	registry = new FinalizationRegistry((unsubscribe) => {
+		if (typeof unsubscribe === "function") unsubscribe();
+	});
+	register(object, unsubscribe, unregisterToken) {
+		this.registry.register(object, unsubscribe, unregisterToken);
+	}
+	unregister(unregisterToken) {
+		this.registry.unregister(unregisterToken);
+	}
+	reset() {}
 };
+//#endregion
+export { FinalizationRegistryBasedCleanupTracking };

package/dist/TreeView/internals/utils/TimerBasedCleanupTracking.js

@@ -1,38 +1,34 @@
-const CLEANUP_TIMER_LOOP_MILLIS = 1e3;
-class TimerBasedCleanupTracking {
-  timeouts = /* @__PURE__ */ new Map();
-  cleanupTimeout = CLEANUP_TIMER_LOOP_MILLIS;
-  constructor(timeout = CLEANUP_TIMER_LOOP_MILLIS) {
-    this.cleanupTimeout = timeout;
-  }
-  register(object, unsubscribe, unregisterToken) {
-    if (!this.timeouts) {
-      this.timeouts = /* @__PURE__ */ new Map();
-    }
-    const timeout = setTimeout(() => {
-      if (typeof unsubscribe === "function") {
-        unsubscribe();
-      }
-      this.timeouts.delete(unregisterToken.cleanupToken);
-    }, this.cleanupTimeout);
-    this.timeouts.set(unregisterToken.cleanupToken, timeout);
-  }
-  unregister(unregisterToken) {
-    const timeout = this.timeouts.get(unregisterToken.cleanupToken);
-    if (timeout) {
-      this.timeouts.delete(unregisterToken.cleanupToken);
-      clearTimeout(timeout);
-    }
-  }
-  reset() {
-    if (this.timeouts) {
-      this.timeouts.forEach((value, key) => {
-        this.unregister({ cleanupToken: key });
-      });
-      this.timeouts = void 0;
-    }
-  }
-}
-export {
-  TimerBasedCleanupTracking
+//#region src/TreeView/internals/utils/TimerBasedCleanupTracking.ts
+var CLEANUP_TIMER_LOOP_MILLIS = 1e3;
+var TimerBasedCleanupTracking = class {
+	timeouts = /* @__PURE__ */ new Map();
+	cleanupTimeout = CLEANUP_TIMER_LOOP_MILLIS;
+	constructor(timeout = CLEANUP_TIMER_LOOP_MILLIS) {
+		this.cleanupTimeout = timeout;
+	}
+	register(object, unsubscribe, unregisterToken) {
+		if (!this.timeouts) this.timeouts = /* @__PURE__ */ new Map();
+		const timeout = setTimeout(() => {
+			if (typeof unsubscribe === "function") unsubscribe();
+			this.timeouts.delete(unregisterToken.cleanupToken);
+		}, this.cleanupTimeout);
+		this.timeouts.set(unregisterToken.cleanupToken, timeout);
+	}
+	unregister(unregisterToken) {
+		const timeout = this.timeouts.get(unregisterToken.cleanupToken);
+		if (timeout) {
+			this.timeouts.delete(unregisterToken.cleanupToken);
+			clearTimeout(timeout);
+		}
+	}
+	reset() {
+		if (this.timeouts) {
+			this.timeouts.forEach((value, key) => {
+				this.unregister({ cleanupToken: key });
+			});
+			this.timeouts = void 0;
+		}
+	}
 };
+//#endregion
+export { TimerBasedCleanupTracking };

package/dist/TreeView/internals/utils/publishTreeViewEvent.js

@@ -1,6 +1,6 @@
-const publishTreeViewEvent = (instance, eventName, params) => {
-  instance.$$publishEvent(eventName, params);
-};
-export {
-  publishTreeViewEvent
+//#region src/TreeView/internals/utils/publishTreeViewEvent.ts
+var publishTreeViewEvent = (instance, eventName, params) => {
+	instance.$$publishEvent(eventName, params);
 };
+//#endregion
+export { publishTreeViewEvent };

package/dist/Typography/Typography.js

@@ -1,55 +1,38 @@
-import { jsx } from "react/jsx-runtime";
-import { useDefaultProps, useTheme } from "@hitachivantara/uikit-react-utils";
 import { fixedForwardRef } from "../types/generic.js";
 import { useClasses } from "./Typography.styles.js";
-import { staticClasses } from "./Typography.styles.js";
-const HvTypographyMap = {
-  display: "h1",
-  title1: "h1",
-  title2: "h2",
-  title3: "h3",
-  title4: "h4",
-  body: "p",
-  label: "span",
-  captionLabel: "div",
-  caption1: "div",
-  caption2: "div"
+import { useDefaultProps, useTheme } from "@hitachivantara/uikit-react-utils";
+import { jsx } from "react/jsx-runtime";
+//#region src/Typography/Typography.tsx
+var HvTypographyMap = {
+	display: "h1",
+	title1: "h1",
+	title2: "h2",
+	title3: "h3",
+	title4: "h4",
+	body: "p",
+	label: "span",
+	captionLabel: "div",
+	caption1: "div",
+	caption2: "div"
 };
-const HvTypography = fixedForwardRef(function HvTypography2(props, ref) {
-  const {
-    className,
-    component: ComponentProp,
-    classes: classesProp,
-    variant = "body",
-    link,
-    noWrap,
-    disabled,
-    ...others
-  } = useDefaultProps("HvTypography", props);
-  const { classes, css, cx } = useClasses(classesProp);
-  const { activeTheme } = useTheme();
-  const Component = ComponentProp || HvTypographyMap[variant] || "span";
-  return /* @__PURE__ */ jsx(
-    Component,
-    {
-      ref,
-      "data-variant": variant,
-      className: cx(
-        css({ ...activeTheme?.typography[variant] }),
-        classes.root,
-        {
-          [classes.isLink]: link,
-          [classes.noWrap]: noWrap,
-          [classes.disabled]: disabled
-        },
-        className
-      ),
-      disabled,
-      ...others
-    }
-  );
+/**
+* Typography component is used to render text and paragraphs within an interface.
+*/
+var HvTypography = fixedForwardRef(function HvTypography(props, ref) {
+	const { className, component: ComponentProp, classes: classesProp, variant = "body", link, noWrap, disabled, ...others } = useDefaultProps("HvTypography", props);
+	const { classes, css, cx } = useClasses(classesProp);
+	const { activeTheme } = useTheme();
+	return /* @__PURE__ */ jsx(ComponentProp || HvTypographyMap[variant] || "span", {
+		ref,
+		"data-variant": variant,
+		className: cx(css({ ...activeTheme?.typography[variant] }), classes.root, {
+			[classes.isLink]: link,
+			[classes.noWrap]: noWrap,
+			[classes.disabled]: disabled
+		}, className),
+		disabled,
+		...others
+	});
 });
-export {
-  HvTypography,
-  staticClasses as typographyClasses
-};
+//#endregion
+export { HvTypography };

package/dist/Typography/Typography.styles.js

@@ -1,25 +1,22 @@
-import { createClasses } from "@hitachivantara/uikit-react-utils";
 import { theme } from "@hitachivantara/uikit-styles";
-const { useClasses, staticClasses } = createClasses("HvTypography", {
-  root: {
-    fontFamily: theme.fontFamily.body,
-    color: "inherit"
-  },
-  disabled: {
-    color: theme.colors.textDisabled
-  },
-  isLink: {
-    cursor: "pointer",
-    color: theme.colors.primary,
-    textDecoration: "underline"
-  },
-  noWrap: {
-    overflow: "hidden",
-    textOverflow: "ellipsis",
-    whiteSpace: "nowrap"
-  }
+import { createClasses } from "@hitachivantara/uikit-react-utils";
+//#region src/Typography/Typography.styles.ts
+var { useClasses, staticClasses } = createClasses("HvTypography", {
+	root: {
+		fontFamily: theme.fontFamily.body,
+		color: "inherit"
+	},
+	disabled: { color: theme.colors.textDisabled },
+	isLink: {
+		cursor: "pointer",
+		color: theme.colors.primary,
+		textDecoration: "underline"
+	},
+	noWrap: {
+		overflow: "hidden",
+		textOverflow: "ellipsis",
+		whiteSpace: "nowrap"
+	}
 });
-export {
-  staticClasses,
-  useClasses
-};
+//#endregion
+export { staticClasses, useClasses };