@m4l/components 7.0.0 → 7.1.2

package/components/GridLayout/utils.d.ts

@@ -2,12 +2,17 @@ import { CompactType, Layout, LayoutItem, Layouts, Position } from './types';
 export declare const noop: () => void;
 /**
  * Return the bottom coordinate of the layout.
- *
  * @param  {Array} layout Layout array.
- * @return {Number}       Bottom coordinate.
+ * @returns {Number}       Bottom coordinate.
  */
 export declare function bottom(layout: Layout, colapsedHeight: number, rowHeight: number): number;
+/**
+ * TODO: Documentar
+ */
 export declare function cloneLayoutItem(layoutItem: LayoutItem, layoutItemReplaceProps?: Partial<Exclude<LayoutItem, 'i'>>): LayoutItem;
+/**
+ * TODO: Documentar
+ */
 export declare function cloneLayout(layout: Layout, layoutItemReplaceProps?: Partial<Exclude<LayoutItem, 'i'>>): Layout;
 /**
  * Given two layoutitems, check if they collide.
@@ -25,43 +30,45 @@ export declare function compactItem(compareWith: Layout, l: LayoutItem, compactT
  * between items.
  *
  * Does not modify layout items (clones). Creates a new layout array.
- *
  * @param  {Array} layout Layout.
  * @param  {CompactType} compactType
  * @param  {Boolean} allowOverlap When `true`, allows overlapping grid items.
- * @return {Array}       Compacted Layout.
+ * @returns {Array}       Compacted Layout.
  */
 export declare function compact(layout: Layout, compactType: CompactType, cols: number, colapsedHeight: number, rowHeight: number, allowOverlap?: boolean): Layout;
 /**
  * Get a layout item by ID. Used so we can override later on if necessary.
- *
  * @param  {Array}  layout Layout array.
  * @param  {String} id     ID
- * @return {LayoutItem}    Item at ID.
+ * @returns {LayoutItem}    Item at ID.
  */
 export declare function getLayoutItem(layout: Layout, id: string): LayoutItem | undefined;
 /**
  * Get all static elements.
  * @param  {Array} layout Array of layout objects.
- * @return {Array}        Array of static layout items..
+ * @returns {Array}        Array of static layout items..
  */
 export declare function getStatics(layout: Layout): Array<LayoutItem>;
 export declare function fastPositionEqual(a: Position, b: Position): boolean;
+/**
+ * TODO: Documentar
+ */
 export declare function getAllCollisions(layout: Layout, layoutItem: LayoutItem, colapsedHeight: number, rowHeight: number): Array<LayoutItem>;
 /**
  * Returns the first item this layout collides with.
  * It doesn't appear to matter which order we approach this from, although
  * perhaps that is the wrong thing to do.
- *
  * @param  {Object} layoutItem Layout item.
- * @return {Object|undefined}  A colliding layout item, or undefined.
+ * @returns {Object|undefined}  A colliding layout item, or undefined.
  */
 export declare function getFirstCollision(layout: Layout, layoutItem: LayoutItem, colapsedHeight: number, rowHeight: number): LayoutItem | undefined;
+/**
+ * TODO: Documentar
+ */
 export declare function modifyLayout(layout: Layout, layoutItem: LayoutItem): Layout;
 /**
  * This is where the magic needs to happen - given a collision, move an element away from the collision.
  * We attempt to move it up if there's room, otherwise it goes below.
- *
  * @param  {Array} layout            Full layout to modify.
  * @param  {LayoutItem} collidesWith Layout item we're colliding with.
  * @param  {LayoutItem} itemToMove   Layout item we're moving.
@@ -71,7 +78,6 @@ export declare function moveElementAwayFromCollision(layout: Layout, collidesWit
  * Move an element. Responsible for doing cascading movements of other elements.
  *
  * Modifies layout items.
- *
  * @param  {Array}      layout            Full layout to modify.
  * @param  {LayoutItem} l                 element to move.
  * @param  {Number}     [x]               X position in grid units.
@@ -80,12 +86,17 @@ export declare function moveElementAwayFromCollision(layout: Layout, collidesWit
 export declare function moveElement(layout: Layout, l: LayoutItem, x: number | undefined, y: number | undefined, isUserAction: boolean, preventCollision: boolean, compactType: CompactType, cols: number, colapsedHeight: number, rowHeight: number, allowOverlap: boolean): Layout;
 /**
  * Helper to convert a number to a percentage string.
- *
  * @param  {Number} num Any number
- * @return {String}     That number as a percentage.
+ * @returns {String}     That number as a percentage.
  */
 export declare function perc(num: number): string;
+/**
+ * TODO: Documentar
+ */
 export declare function setTransform({ top, left, width, height }: Position): Record<string, any>;
+/**
+ * TODO: Documentar
+ */
 export declare function setTopLeft({ top, left, width, height }: Position): Record<string, any>;
 /**
  * Sort layout items by row ascending and column ascending.
@@ -101,25 +112,41 @@ export declare function sortLayoutItemsByRowCol(layout: Layout): Layout;
 export declare function sortLayoutItemsByColRow(layout: Layout): Layout;
 /**
  * Get layout items sorted from top left to right and down.
- *
- * @return {Array} Array of layout objects.
- * @return {Array}        Layout, sorted static items first.
+ * @returns {Array} Array of layout objects.
+ * @returns {Array}        Layout, sorted static items first.
  */
 export declare function sortLayoutItems(layout: Layout, compactType: CompactType): Layout;
+/**
+ * TODO: Documentar
+ */
 export declare function withLayoutItem(layout: Layout, itemKey: string, cb: (l: LayoutItem) => LayoutItem): [Layout, LayoutItem | undefined];
 /**
  * Given a layout, make sure all elements fit within its bounds.
  *
  * Modifies layout items.
- *
  * @param  {Array} layout Layout array.
  * @param  {Number} bounds Number of columns.
  */
 export declare function correctBounds(layout: Layout, bounds: {
     cols: number;
 }, colapsedHeight: number, rowHeight: number): Layout;
+/**
+ * TODO: Documentar
+ */
 export declare function getH(h: number, colapsedHeight: number, rowHeight: number, colapsed?: boolean): number;
+/**
+ * TODO: Documentar
+ */
 export declare function getLayoutItemH(layoutItem: LayoutItem, colapsedHeight: number, rowHeight: number): number;
+/**
+ * TODO: Documentar
+ */
 export declare function isEqualLayoutItem(layoutA: LayoutItem, layoutB: LayoutItem): boolean;
+/**
+ * TODO: Documentar
+ */
 export declare function isEqualLayout(layoutA: Layout, layoutB: Layout): boolean;
+/**
+ * TODO: Documentar
+ */
 export declare function isEqualLayouts(layoutsA: Layouts, layoutsB: Layouts): boolean;

package/components/GridLayout/utils.js

@@ -0,0 +1,450 @@
+import { c as DEFAULT_ROW_HEIGHT } from "./constants.js";
+const noop = () => {
+};
+function bottom(layout, colapsedHeight, rowHeight) {
+  let max = 0, bottomY;
+  for (let i = 0, len = layout.length; i < len; i++) {
+    bottomY = layout[i].y + getLayoutItemH(layout[i], colapsedHeight, rowHeight);
+    if (bottomY > max) {
+      max = bottomY;
+    }
+  }
+  return max;
+}
+function cloneLayoutItem(layoutItem, layoutItemReplaceProps) {
+  return {
+    w: layoutItem.w,
+    h: layoutItem.h,
+    x: layoutItem.x,
+    y: layoutItem.y,
+    i: layoutItem.i,
+    minW: layoutItem.minW,
+    maxW: layoutItem.maxW,
+    minH: layoutItem.minH,
+    maxH: layoutItem.maxH,
+    moved: Boolean(layoutItem.moved),
+    static: Boolean(layoutItem.static),
+    // These can be null/undefined
+    isDraggable: layoutItem.isDraggable,
+    isResizable: layoutItem.isResizable,
+    resizeHandles: layoutItem.resizeHandles,
+    isBounded: layoutItem.isBounded,
+    freeMove: layoutItem.freeMove,
+    colapsed: layoutItem.colapsed,
+    visible: layoutItem.visible,
+    ...layoutItemReplaceProps
+  };
+}
+function cloneLayout(layout, layoutItemReplaceProps) {
+  const newLayout = Array(layout.length);
+  for (let i = 0, len = layout.length; i < len; i++) {
+    newLayout[i] = cloneLayoutItem(layout[i], layoutItemReplaceProps);
+  }
+  return newLayout;
+}
+function collides(l1, l2, colapsedHeight, rowHeight) {
+  if (l1.i === l2.i) {
+    return false;
+  }
+  if (l1.x + l1.w <= l2.x) {
+    return false;
+  }
+  if (l1.x >= l2.x + l2.w) {
+    return false;
+  }
+  if (l1.y + getLayoutItemH(l1, colapsedHeight, rowHeight) <= l2.y) {
+    return false;
+  }
+  if (l1.y >= l2.y + getLayoutItemH(l2, colapsedHeight, rowHeight)) {
+    return false;
+  }
+  return true;
+}
+function compactItem(compareWith, l, compactType, cols, fullLayout, colapsedHeight, rowHeight, allowOverlap) {
+  const compactV = compactType === "vertical";
+  const compactH = compactType === "horizontal";
+  if (compactV) {
+    l.y = Math.min(bottom(compareWith, colapsedHeight, rowHeight), l.y);
+    while (l.y > 0 && !getFirstCollision(compareWith, l, colapsedHeight, rowHeight)) {
+      l.y--;
+    }
+  } else if (compactH) {
+    while (l.x > 0 && !getFirstCollision(compareWith, l, colapsedHeight, rowHeight)) {
+      l.x--;
+    }
+  }
+  let collidesItem;
+  while ((collidesItem = getFirstCollision(compareWith, l, colapsedHeight, rowHeight)) && !(compactType === null && allowOverlap)) {
+    if (compactH) {
+      resolveCompactionCollision(
+        fullLayout,
+        l,
+        collidesItem.x + collidesItem.w,
+        "x",
+        colapsedHeight,
+        rowHeight
+      );
+    } else {
+      resolveCompactionCollision(
+        fullLayout,
+        l,
+        collidesItem.y + getLayoutItemH(collidesItem, colapsedHeight, rowHeight),
+        "y",
+        colapsedHeight,
+        rowHeight
+      );
+    }
+    if (compactH && l.x + l.w > cols) {
+      l.x = cols - l.w;
+      l.y++;
+      while (l.x > 0 && !getFirstCollision(compareWith, l, colapsedHeight, rowHeight)) {
+        l.x--;
+      }
+    }
+  }
+  l.y = Math.max(l.y, 0);
+  l.x = Math.max(l.x, 0);
+  return l;
+}
+function compact(layout, compactType, cols, colapsedHeight, rowHeight, allowOverlap) {
+  const layoutToCompact = layout.filter((l) => !l.freeMove);
+  const layoutFreeMov = layout.filter((l) => l?.freeMove);
+  const compareWith = getStatics(layoutToCompact);
+  const sorted = sortLayoutItems(layoutToCompact, compactType);
+  const out = Array(layoutToCompact.length);
+  for (let i = 0, len = sorted.length; i < len; i++) {
+    let l = cloneLayoutItem(sorted[i]);
+    if (!l.static) {
+      l = compactItem(
+        compareWith,
+        l,
+        compactType,
+        cols,
+        sorted,
+        colapsedHeight,
+        rowHeight,
+        allowOverlap
+      );
+      compareWith.push(l);
+    }
+    out[layoutToCompact.indexOf(sorted[i])] = l;
+    l.moved = false;
+  }
+  return out.concat(layoutFreeMov);
+}
+function getLayoutItem(layout, id) {
+  for (let i = 0, len = layout.length; i < len; i++) {
+    if (layout[i].i === id) {
+      return layout[i];
+    }
+  }
+  return void 0;
+}
+function getStatics(layout) {
+  return layout.filter((l) => l.static);
+}
+function getAllCollisions(layout, layoutItem, colapsedHeight, rowHeight) {
+  return layout.filter((l) => collides(l, layoutItem, colapsedHeight, rowHeight));
+}
+function getFirstCollision(layout, layoutItem, colapsedHeight, rowHeight) {
+  for (let i = 0, len = layout.length; i < len; i++) {
+    if (collides(layout[i], layoutItem, colapsedHeight, rowHeight)) {
+      return layout[i];
+    }
+  }
+  return void 0;
+}
+function modifyLayout(layout, layoutItem) {
+  const newLayout = Array(layout.length);
+  for (let i = 0, len = layout.length; i < len; i++) {
+    if (layoutItem.i === layout[i].i) {
+      newLayout[i] = layoutItem;
+    } else {
+      newLayout[i] = layout[i];
+    }
+  }
+  return newLayout;
+}
+function moveElementAwayFromCollision(layout, collidesWith, itemToMove, isUserAction, compactType, cols, colapsedHeight, rowHeight) {
+  const compactH = compactType === "horizontal";
+  const compactV = compactType !== "horizontal";
+  const preventCollision = collidesWith.static;
+  if (isUserAction) {
+    isUserAction = false;
+    const fakeItem = {
+      x: compactH ? Math.max(collidesWith.x - itemToMove.w, 0) : itemToMove.x,
+      y: compactV ? Math.max(collidesWith.y - getLayoutItemH(itemToMove, colapsedHeight, rowHeight), 0) : itemToMove.y,
+      w: itemToMove.w,
+      h: getLayoutItemH(itemToMove, colapsedHeight, rowHeight),
+      i: "-1"
+    };
+    if (!getFirstCollision(layout, fakeItem, colapsedHeight, rowHeight)) {
+      return moveElement(
+        layout,
+        itemToMove,
+        compactH ? fakeItem.x : void 0,
+        compactV ? fakeItem.y : void 0,
+        isUserAction,
+        !!preventCollision,
+        compactType,
+        cols,
+        colapsedHeight,
+        rowHeight,
+        false
+      );
+    }
+  }
+  return moveElement(
+    layout,
+    itemToMove,
+    compactH ? itemToMove.x + 1 : void 0,
+    compactV ? itemToMove.y + 1 : void 0,
+    isUserAction,
+    !!preventCollision,
+    compactType,
+    cols,
+    colapsedHeight,
+    rowHeight,
+    false
+  );
+}
+function moveElement(layout, l, x, y, isUserAction, preventCollision, compactType, cols, colapsedHeight, rowHeight, allowOverlap) {
+  if (l.static && l.isDraggable !== true) {
+    return layout;
+  }
+  if (l.y === y && l.x === x) {
+    return layout;
+  }
+  const oldX = l.x;
+  const oldY = l.y;
+  if (typeof x === "number") {
+    l.x = x;
+  }
+  if (typeof y === "number") {
+    l.y = y;
+  }
+  l.moved = true;
+  let sorted = sortLayoutItems(layout, compactType);
+  const movingUp = compactType === "vertical" && typeof y === "number" ? oldY >= y : compactType === "horizontal" && typeof x === "number" ? oldX >= x : false;
+  if (movingUp) {
+    sorted = sorted.reverse();
+  }
+  const collisions = getAllCollisions(sorted, l, colapsedHeight, rowHeight);
+  const hasCollisions = collisions.length > 0;
+  if (hasCollisions && allowOverlap) {
+    return cloneLayout(layout);
+  } else if (hasCollisions && preventCollision) {
+    l.x = oldX;
+    l.y = oldY;
+    l.moved = false;
+    return layout;
+  }
+  for (let i = 0, len = collisions.length; i < len; i++) {
+    const collision = collisions[i];
+    if (collision.moved) {
+      continue;
+    }
+    if (collision.static) {
+      layout = moveElementAwayFromCollision(
+        layout,
+        collision,
+        l,
+        isUserAction,
+        compactType,
+        cols,
+        colapsedHeight,
+        rowHeight
+      );
+    } else {
+      layout = moveElementAwayFromCollision(
+        layout,
+        l,
+        collision,
+        isUserAction,
+        compactType,
+        cols,
+        colapsedHeight,
+        rowHeight
+      );
+    }
+  }
+  return layout;
+}
+function perc(num) {
+  return num * 100 + "%";
+}
+function resolveCompactionCollision(layout, item, moveToCoord, axis, colapsedHeight, rowHeight) {
+  item[axis] += 1;
+  const itemIndex = layout.map((layoutItem) => {
+    return layoutItem.i;
+  }).indexOf(item.i);
+  for (let i = itemIndex + 1; i < layout.length; i++) {
+    const otherItem = layout[i];
+    if (otherItem.static) {
+      continue;
+    }
+    if (otherItem.y > item.y + getLayoutItemH(item, colapsedHeight, rowHeight)) {
+      break;
+    }
+    if (collides(item, otherItem, colapsedHeight, rowHeight)) {
+      resolveCompactionCollision(
+        layout,
+        otherItem,
+        moveToCoord + (axis === "x" ? item.w : getLayoutItemH(item, colapsedHeight, rowHeight)),
+        axis,
+        colapsedHeight,
+        rowHeight
+      );
+    }
+  }
+  item[axis] = moveToCoord;
+}
+function setTransform({ top, left, width, height }) {
+  return {
+    /*  transform: translate,
+        WebkitTransform: translate,
+        MozTransform: translate,
+        msTransform: translate,
+        OTransform: translate, */
+    width: `${width}px`,
+    height: `${height}px`,
+    position: "absolute",
+    left,
+    top
+  };
+}
+function setTopLeft({ top, left, width, height }) {
+  return {
+    top: `${top}px`,
+    left: `${left}px`,
+    width: `${width}px`,
+    height: `${height}px`,
+    position: "absolute"
+  };
+}
+function sortLayoutItemsByRowCol(layout) {
+  return layout.slice(0).sort(function(a, b) {
+    if (a.y > b.y || a.y === b.y && a.x > b.x) {
+      return 1;
+    } else if (a.y === b.y && a.x === b.x) {
+      return 0;
+    }
+    return -1;
+  });
+}
+function sortLayoutItemsByColRow(layout) {
+  return layout.slice(0).sort(function(a, b) {
+    if (a.x > b.x || a.x === b.x && a.y > b.y) {
+      return 1;
+    }
+    return -1;
+  });
+}
+function sortLayoutItems(layout, compactType) {
+  if (compactType === "horizontal") {
+    return sortLayoutItemsByColRow(layout);
+  }
+  if (compactType === "vertical") {
+    return sortLayoutItemsByRowCol(layout);
+  } else {
+    return layout;
+  }
+}
+function withLayoutItem(layout, itemKey, cb) {
+  let item = getLayoutItem(layout, itemKey);
+  if (!item) {
+    return [layout, void 0];
+  }
+  item = cb(cloneLayoutItem(item));
+  layout = modifyLayout(layout, item);
+  return [layout, item];
+}
+function correctBounds(layout, bounds, colapsedHeight, rowHeight) {
+  const collidesWith = getStatics(layout);
+  for (let i = 0, len = layout.length; i < len; i++) {
+    const l = layout[i];
+    if (l.x + l.w > bounds.cols) {
+      l.x = bounds.cols - l.w;
+    }
+    if (l.x < 0) {
+      l.x = 0;
+      l.w = bounds.cols;
+    }
+    if (!l.static) {
+      collidesWith.push(l);
+    } else {
+      while (getFirstCollision(collidesWith, l, colapsedHeight, rowHeight)) {
+        l.y++;
+      }
+    }
+  }
+  return layout;
+}
+function getH(h, colapsedHeight, rowHeight, colapsed) {
+  if (colapsed) {
+    let ret;
+    if (rowHeight && rowHeight > 0) {
+      ret = colapsedHeight / rowHeight;
+    } else {
+      ret = colapsedHeight / DEFAULT_ROW_HEIGHT;
+    }
+    return ret;
+  }
+  return h;
+}
+function getLayoutItemH(layoutItem, colapsedHeight, rowHeight) {
+  return getH(layoutItem.h, colapsedHeight, rowHeight, layoutItem.colapsed);
+}
+function isEqualLayoutItem(layoutA, layoutB) {
+  if (layoutA.i !== layoutB.i) {
+    return false;
+  } else if (layoutA.x !== layoutB.x || layoutA.y !== layoutB.y || layoutA.w !== layoutB.w || layoutA.h !== layoutB.h || layoutA.colapsed !== layoutB.colapsed || layoutA.visible !== layoutB.visible || layoutA.freeMove !== layoutB.freeMove) {
+    return false;
+  }
+  return true;
+}
+function isEqualLayout(layoutA, layoutB) {
+  if (layoutA.length !== layoutB.length) {
+    return false;
+  }
+  for (let index = 0; index < layoutA.length; index++) {
+    if (!isEqualLayoutItem(layoutA[index], layoutB[index])) {
+      return false;
+    }
+  }
+  return true;
+}
+function isEqualLayouts(layoutsA, layoutsB) {
+  if (Object.keys(layoutsA).length !== Object.keys(layoutsB).length) {
+    return false;
+  }
+  for (const breakPoint in layoutsA) {
+    if (layoutsB[breakPoint]) {
+      if (!isEqualLayout(layoutsA[breakPoint], layoutsB[breakPoint])) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+export {
+  cloneLayoutItem as a,
+  getLayoutItemH as b,
+  cloneLayout as c,
+  compact as d,
+  bottom as e,
+  getAllCollisions as f,
+  getLayoutItem as g,
+  getH as h,
+  isEqualLayout as i,
+  setTopLeft as j,
+  isEqualLayouts as k,
+  correctBounds as l,
+  moveElement as m,
+  noop as n,
+  perc as p,
+  setTransform as s,
+  withLayoutItem as w
+};

package/components/HelmetPage/index.d.ts

@@ -1,4 +1,7 @@
 import { HelmetPageProps } from './types';
+/**
+ * TODO: Documentar
+ */
 export declare const HelmetPage: {
     (props: HelmetPageProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;

package/components/HelmetPage/index.js

@@ -0,0 +1,21 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { Helmet } from "react-helmet-async";
+import { useLocales } from "@m4l/graphics";
+import { useModuleSkeleton } from "@m4l/core";
+const HelmetPage = (props) => {
+  const { children, title, meta, subtitle } = props;
+  const localeString = useLocales().currentLocale?.localeString;
+  const isSkeleton = useModuleSkeleton();
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    !isSkeleton && /* @__PURE__ */ jsxs(Helmet, { children: [
+      /* @__PURE__ */ jsx("title", { children: `${title}${subtitle ? ` | ${subtitle}` : ""} ` }),
+      /* @__PURE__ */ jsx("html", { lang: localeString }),
+      meta
+    ] }),
+    children
+  ] });
+};
+HelmetPage.displayName = "Page";
+export {
+  HelmetPage as H
+};

package/components/HelmetPage/types.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import { ReactNode } from 'react';
 export interface HelmetPageProps {
     children: ReactNode;
     meta?: ReactNode;

package/components/HelperError/HelperError.js

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { T as TypographyStyled } from "./slots/HelperErrorSlots.js";
+const HelperError = (props) => {
+  const { message = "", skeletonWidth, skeletonHeight } = props;
+  return /* @__PURE__ */ jsx(
+    TypographyStyled,
+    {
+      ownerState: {},
+      variant: "body1",
+      skeletonWidth,
+      skeletonHeight,
+      children: message
+    }
+  );
+};
+export {
+  HelperError as H
+};

package/components/HelperError/HelperError.stories.d.ts

@@ -0,0 +1,7 @@
+import { HelperError } from './HelperError';
+import { Meta, StoryObj } from '@storybook/react';
+declare const meta: Meta<typeof HelperError>;
+export default meta;
+type Story = StoryObj<typeof HelperError>;
+/** Base HelperError component  */
+export declare const Base: Story;

package/components/HelperError/HelperError.styles.js

@@ -0,0 +1,13 @@
+const helperErrorStyles = {
+  /**
+   * TODO: Documentar
+   */
+  root: ({ theme }) => ({
+    "& .MuiTypography-root": {
+      color: theme.vars.palette.error.main
+    }
+  })
+};
+export {
+  helperErrorStyles as h
+};

package/components/HelperError/constant.js

@@ -0,0 +1,4 @@
+const HELPER_ERROR_KEY_COMPONENT = "M4LHelperError";
+export {
+  HELPER_ERROR_KEY_COMPONENT as H
+};

package/components/HelperError/index.js

@@ -0,0 +1 @@
+

package/components/HelperError/slots/HelperErrorEnum.js

@@ -0,0 +1,7 @@
+var HelperErrorSlots = /* @__PURE__ */ ((HelperErrorSlots2) => {
+  HelperErrorSlots2["root"] = "root";
+  return HelperErrorSlots2;
+})(HelperErrorSlots || {});
+export {
+  HelperErrorSlots as H
+};