@fangzhongya/page 0.0.31 → 0.0.32

package/dist/components/design/grids/helpers/utils.cjs

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const helpers = require("../types/helpers.cjs");
+function bottom(layout) {
+  let max = 0;
+  let bottomY;
+  for (let i = 0; i < layout.length; i++) {
+    bottomY = layout[i].y + layout[i].h;
+    if (bottomY > max) max = bottomY;
+  }
+  return max;
+}
+const cloneLayoutItem = (layoutItem) => JSON.parse(JSON.stringify(layoutItem));
+function cloneLayout(layout) {
+  const newLayout = Array(layout.length);
+  for (let i = 0; i < layout.length; i++)
+    newLayout[i] = cloneLayoutItem(layout[i]);
+  return newLayout;
+}
+function collides(l1, l2) {
+  return !(l1 === l2 || l1.x + l1.w <= l2.x || l1.x >= l2.x + l2.w || l1.y + l1.h <= l2.y || l1.y >= l2.y + l2.h);
+}
+const getStatics = (layout) => layout.filter((l) => l.isStatic);
+function compact(layout, verticalCompact) {
+  if (!layout) return;
+  const compareWith = getStatics(layout);
+  const sorted = sortLayoutItemsByRowCol(layout);
+  const out = Array(layout.length);
+  for (let i = 0; i < sorted.length; i++) {
+    let l = sorted[i];
+    if (!l.isStatic) {
+      l = compactItem(compareWith, l, verticalCompact);
+      compareWith.push(l);
+    }
+    out[layout.indexOf(l)] = l;
+    l.moved = false;
+  }
+  return out;
+}
+function getFirstCollision(layout, layoutItem) {
+  for (let i = 0, len = layout.length; i < len; i++) {
+    if (collides(layout[i], layoutItem)) return layout[i];
+  }
+}
+function compactItem(compareWith, l, verticalCompact) {
+  if (verticalCompact)
+    while (l.y > 0 && !getFirstCollision(compareWith, l)) l.y--;
+  let collides2 = getFirstCollision(compareWith, l);
+  while (collides2) {
+    l.y = collides2.y + collides2.h;
+    collides2 = getFirstCollision(compareWith, l);
+  }
+  return l;
+}
+function correctBounds(layout, bounds) {
+  const collidesWith = getStatics(layout);
+  for (let i = 0; i < layout.length; 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.isStatic) collidesWith.push(l);
+    else while (getFirstCollision(collidesWith, l)) l.y++;
+  }
+  return layout;
+}
+function getAllCollisions(layout, layoutItem) {
+  return layout.filter((l) => collides(l, layoutItem));
+}
+const getLayoutItem = (layout, id) => layout.filter((l) => l.id === id)[0];
+function moveElement(layout, l, x, y, isUserAction, horizontalShift, preventCollision) {
+  if (l.isStatic) return layout;
+  const oldX = l.x;
+  const oldY = l.y;
+  const moving = {
+    DOWN: oldY < y,
+    LEFT: oldX > x,
+    RIGHT: oldX < x,
+    UP: oldY > y
+  };
+  l.x = x;
+  l.y = y;
+  l.moved = true;
+  let sorted = sortLayoutItemsByRowCol(layout);
+  if (moving.UP) sorted = sorted.reverse();
+  const collisions = getAllCollisions(sorted, l);
+  if (preventCollision && collisions.length) {
+    l.x = oldX;
+    l.y = oldY;
+    l.moved = false;
+    return layout;
+  }
+  for (let i = 0; i < collisions.length; i++) {
+    const collision = collisions[i];
+    if (collision.moved) continue;
+    if (l.y > collision.y && l.y - collision.y > collision.h / 4) continue;
+    const movingDirection = Object.keys(moving).filter((k) => moving[k])?.[0];
+    if (collision.isStatic)
+      layout = moveElementAwayFromCollision(
+        layout,
+        collision,
+        l,
+        isUserAction,
+        movingDirection,
+        horizontalShift
+      );
+    else
+      layout = moveElementAwayFromCollision(
+        layout,
+        l,
+        collision,
+        isUserAction,
+        movingDirection,
+        horizontalShift
+      );
+  }
+  return layout;
+}
+function moveElementAwayFromCollision(layout, collidesWith, itemToMove, isUserAction, movingDirection, horizontalShift) {
+  const preventCollision = false;
+  if (isUserAction) {
+    const fakeItem = {
+      h: itemToMove.h,
+      id: -1,
+      w: itemToMove.w,
+      x: itemToMove.x,
+      y: Math.max(collidesWith.y - itemToMove.h, 0)
+    };
+    if (!getFirstCollision(layout, fakeItem))
+      return moveElement(
+        layout,
+        itemToMove,
+        fakeItem.x,
+        fakeItem.y,
+        isUserAction,
+        horizontalShift,
+        preventCollision
+      );
+  }
+  const movingCordsData = {
+    $default: {
+      x: itemToMove.x,
+      y: itemToMove.y + 1
+    },
+    [helpers.MovingDirections.LEFT]: [
+      itemToMove.x + collidesWith.w,
+      collidesWith.y
+    ],
+    [helpers.MovingDirections.RIGHT]: [
+      itemToMove.x - collidesWith.w,
+      collidesWith.y
+    ],
+    [helpers.MovingDirections.UP]: [itemToMove.x, itemToMove.y + collidesWith.h],
+    [helpers.MovingDirections.DOWN]: [itemToMove.x, itemToMove.y - collidesWith.h]
+  };
+  if (horizontalShift) {
+    const horizontalDirection = movingDirection === helpers.MovingDirections.LEFT || movingDirection === helpers.MovingDirections.RIGHT;
+    if (movingDirection in movingCordsData && !(horizontalDirection && collidesWith.w < itemToMove.w && collidesWith.x !== itemToMove.x)) {
+      const [x, y] = movingCordsData[movingDirection];
+      movingCordsData.$default.x = x;
+      movingCordsData.$default.y = y;
+    }
+  }
+  return moveElement(
+    layout,
+    itemToMove,
+    movingCordsData.$default.x,
+    movingCordsData.$default.y,
+    horizontalShift,
+    preventCollision
+  );
+}
+function normalizeMargins(margin) {
+  return margin.length === 1 ? [margin[0], margin[0]] : margin;
+}
+const setTopLeft = (top, left, width, height) => {
+  return {
+    height: `${height}px`,
+    left: `${left}px`,
+    position: "absolute",
+    top: `${top}px`,
+    width: `${width}px`
+  };
+};
+function setTransform(top, left, width, height) {
+  return {
+    height: `${height}px`,
+    position: "absolute",
+    transform: `translate3d(${left}px,${top}px, 0)`,
+    width: `${width}px`
+  };
+}
+function sortLayoutItemsByRowCol(layout) {
+  return [...layout].sort((a, b) => {
+    if (a.y === b.y && a.x === b.x) return 0;
+    if (a.y > b.y || a.y === b.y && a.x > b.x) return 1;
+    return -1;
+  });
+}
+function stringReplacer(string, value, replacer) {
+  return string.trim().replace(value, replacer);
+}
+exports.bottom = bottom;
+exports.cloneLayout = cloneLayout;
+exports.cloneLayoutItem = cloneLayoutItem;
+exports.collides = collides;
+exports.compact = compact;
+exports.compactItem = compactItem;
+exports.correctBounds = correctBounds;
+exports.getAllCollisions = getAllCollisions;
+exports.getFirstCollision = getFirstCollision;
+exports.getLayoutItem = getLayoutItem;
+exports.getStatics = getStatics;
+exports.moveElement = moveElement;
+exports.moveElementAwayFromCollision = moveElementAwayFromCollision;
+exports.normalizeMargins = normalizeMargins;
+exports.setTopLeft = setTopLeft;
+exports.setTransform = setTransform;
+exports.sortLayoutItemsByRowCol = sortLayoutItemsByRowCol;
+exports.stringReplacer = stringReplacer;

package/dist/components/design/grids/helpers/utils.d.ts

@@ -0,0 +1,24 @@
+import { CSSProperties } from 'vue';
+import { Id } from '../types/components';
+import { CompleteMargins, Margin } from '../types';
+import { Layout, LayoutItem, MovingDirection, setPositionFnc } from '../types/helpers';
+export declare function bottom(layout: Layout): number;
+export declare const cloneLayoutItem: (layoutItem: LayoutItem) => LayoutItem;
+export declare function cloneLayout(layout: Layout): Layout;
+export declare function collides(l1: LayoutItem, l2: LayoutItem): boolean;
+export declare const getStatics: (layout: Layout) => LayoutItem[];
+export declare function compact(layout: Layout, verticalCompact: boolean): Layout | undefined;
+export declare function getFirstCollision(layout: Layout, layoutItem: LayoutItem): LayoutItem | void;
+export declare function compactItem(compareWith: Layout, l: LayoutItem, verticalCompact: boolean): LayoutItem;
+export declare function correctBounds(layout: Layout, bounds: {
+    cols: number;
+}): Layout;
+export declare function getAllCollisions(layout: Layout, layoutItem: LayoutItem): LayoutItem[];
+export declare const getLayoutItem: (layout: Layout, id: Id) => LayoutItem;
+export declare function moveElement(layout: Layout, l: LayoutItem, x: number, y: number, isUserAction: boolean, horizontalShift: boolean, preventCollision?: boolean): Layout;
+export declare function moveElementAwayFromCollision(layout: Layout, collidesWith: LayoutItem, itemToMove: LayoutItem, isUserAction: boolean, movingDirection: MovingDirection, horizontalShift: boolean): Layout;
+export declare function normalizeMargins(margin: Margin): CompleteMargins;
+export declare const setTopLeft: setPositionFnc<CSSProperties>;
+export declare function setTransform(top: number, left: number, width: number, height: number): CSSProperties;
+export declare function sortLayoutItemsByRowCol(layout: Layout): Layout;
+export declare function stringReplacer(string: string, value: string, replacer: string): string;

package/dist/components/design/grids/helpers/utils.js

@@ -0,0 +1,222 @@
+import { MovingDirections } from "../types/helpers.js";
+function bottom(layout) {
+  let max = 0;
+  let bottomY;
+  for (let i = 0; i < layout.length; i++) {
+    bottomY = layout[i].y + layout[i].h;
+    if (bottomY > max) max = bottomY;
+  }
+  return max;
+}
+const cloneLayoutItem = (layoutItem) => JSON.parse(JSON.stringify(layoutItem));
+function cloneLayout(layout) {
+  const newLayout = Array(layout.length);
+  for (let i = 0; i < layout.length; i++)
+    newLayout[i] = cloneLayoutItem(layout[i]);
+  return newLayout;
+}
+function collides(l1, l2) {
+  return !(l1 === l2 || l1.x + l1.w <= l2.x || l1.x >= l2.x + l2.w || l1.y + l1.h <= l2.y || l1.y >= l2.y + l2.h);
+}
+const getStatics = (layout) => layout.filter((l) => l.isStatic);
+function compact(layout, verticalCompact) {
+  if (!layout) return;
+  const compareWith = getStatics(layout);
+  const sorted = sortLayoutItemsByRowCol(layout);
+  const out = Array(layout.length);
+  for (let i = 0; i < sorted.length; i++) {
+    let l = sorted[i];
+    if (!l.isStatic) {
+      l = compactItem(compareWith, l, verticalCompact);
+      compareWith.push(l);
+    }
+    out[layout.indexOf(l)] = l;
+    l.moved = false;
+  }
+  return out;
+}
+function getFirstCollision(layout, layoutItem) {
+  for (let i = 0, len = layout.length; i < len; i++) {
+    if (collides(layout[i], layoutItem)) return layout[i];
+  }
+}
+function compactItem(compareWith, l, verticalCompact) {
+  if (verticalCompact)
+    while (l.y > 0 && !getFirstCollision(compareWith, l)) l.y--;
+  let collides2 = getFirstCollision(compareWith, l);
+  while (collides2) {
+    l.y = collides2.y + collides2.h;
+    collides2 = getFirstCollision(compareWith, l);
+  }
+  return l;
+}
+function correctBounds(layout, bounds) {
+  const collidesWith = getStatics(layout);
+  for (let i = 0; i < layout.length; 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.isStatic) collidesWith.push(l);
+    else while (getFirstCollision(collidesWith, l)) l.y++;
+  }
+  return layout;
+}
+function getAllCollisions(layout, layoutItem) {
+  return layout.filter((l) => collides(l, layoutItem));
+}
+const getLayoutItem = (layout, id) => layout.filter((l) => l.id === id)[0];
+function moveElement(layout, l, x, y, isUserAction, horizontalShift, preventCollision) {
+  if (l.isStatic) return layout;
+  const oldX = l.x;
+  const oldY = l.y;
+  const moving = {
+    DOWN: oldY < y,
+    LEFT: oldX > x,
+    RIGHT: oldX < x,
+    UP: oldY > y
+  };
+  l.x = x;
+  l.y = y;
+  l.moved = true;
+  let sorted = sortLayoutItemsByRowCol(layout);
+  if (moving.UP) sorted = sorted.reverse();
+  const collisions = getAllCollisions(sorted, l);
+  if (preventCollision && collisions.length) {
+    l.x = oldX;
+    l.y = oldY;
+    l.moved = false;
+    return layout;
+  }
+  for (let i = 0; i < collisions.length; i++) {
+    const collision = collisions[i];
+    if (collision.moved) continue;
+    if (l.y > collision.y && l.y - collision.y > collision.h / 4) continue;
+    const movingDirection = Object.keys(moving).filter((k) => moving[k])?.[0];
+    if (collision.isStatic)
+      layout = moveElementAwayFromCollision(
+        layout,
+        collision,
+        l,
+        isUserAction,
+        movingDirection,
+        horizontalShift
+      );
+    else
+      layout = moveElementAwayFromCollision(
+        layout,
+        l,
+        collision,
+        isUserAction,
+        movingDirection,
+        horizontalShift
+      );
+  }
+  return layout;
+}
+function moveElementAwayFromCollision(layout, collidesWith, itemToMove, isUserAction, movingDirection, horizontalShift) {
+  const preventCollision = false;
+  if (isUserAction) {
+    const fakeItem = {
+      h: itemToMove.h,
+      id: -1,
+      w: itemToMove.w,
+      x: itemToMove.x,
+      y: Math.max(collidesWith.y - itemToMove.h, 0)
+    };
+    if (!getFirstCollision(layout, fakeItem))
+      return moveElement(
+        layout,
+        itemToMove,
+        fakeItem.x,
+        fakeItem.y,
+        isUserAction,
+        horizontalShift,
+        preventCollision
+      );
+  }
+  const movingCordsData = {
+    $default: {
+      x: itemToMove.x,
+      y: itemToMove.y + 1
+    },
+    [MovingDirections.LEFT]: [
+      itemToMove.x + collidesWith.w,
+      collidesWith.y
+    ],
+    [MovingDirections.RIGHT]: [
+      itemToMove.x - collidesWith.w,
+      collidesWith.y
+    ],
+    [MovingDirections.UP]: [itemToMove.x, itemToMove.y + collidesWith.h],
+    [MovingDirections.DOWN]: [itemToMove.x, itemToMove.y - collidesWith.h]
+  };
+  if (horizontalShift) {
+    const horizontalDirection = movingDirection === MovingDirections.LEFT || movingDirection === MovingDirections.RIGHT;
+    if (movingDirection in movingCordsData && !(horizontalDirection && collidesWith.w < itemToMove.w && collidesWith.x !== itemToMove.x)) {
+      const [x, y] = movingCordsData[movingDirection];
+      movingCordsData.$default.x = x;
+      movingCordsData.$default.y = y;
+    }
+  }
+  return moveElement(
+    layout,
+    itemToMove,
+    movingCordsData.$default.x,
+    movingCordsData.$default.y,
+    horizontalShift,
+    preventCollision
+  );
+}
+function normalizeMargins(margin) {
+  return margin.length === 1 ? [margin[0], margin[0]] : margin;
+}
+const setTopLeft = (top, left, width, height) => {
+  return {
+    height: `${height}px`,
+    left: `${left}px`,
+    position: "absolute",
+    top: `${top}px`,
+    width: `${width}px`
+  };
+};
+function setTransform(top, left, width, height) {
+  return {
+    height: `${height}px`,
+    position: "absolute",
+    transform: `translate3d(${left}px,${top}px, 0)`,
+    width: `${width}px`
+  };
+}
+function sortLayoutItemsByRowCol(layout) {
+  return [...layout].sort((a, b) => {
+    if (a.y === b.y && a.x === b.x) return 0;
+    if (a.y > b.y || a.y === b.y && a.x > b.x) return 1;
+    return -1;
+  });
+}
+function stringReplacer(string, value, replacer) {
+  return string.trim().replace(value, replacer);
+}
+export {
+  bottom,
+  cloneLayout,
+  cloneLayoutItem,
+  collides,
+  compact,
+  compactItem,
+  correctBounds,
+  getAllCollisions,
+  getFirstCollision,
+  getLayoutItem,
+  getStatics,
+  moveElement,
+  moveElementAwayFromCollision,
+  normalizeMargins,
+  setTopLeft,
+  setTransform,
+  sortLayoutItemsByRowCol,
+  stringReplacer
+};

package/dist/components/design/grids/types/components.d.ts

@@ -0,0 +1,20 @@
+import { INTERSECTION_OBSERVER_ID } from '../constants';
+export type Dimension = 'h' | 'w' | 'x' | 'y';
+export type Dimensions = Record<Dimension, number>;
+export type GridItemClass = 'css-transforms' | 'disable-user-select' | 'no-touch' | 'resizing' | 'static' | 'vue-draggable-dragging' | 'vue-resizable';
+export interface GridItemPosition {
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+}
+export type GridLayoutEvent<TEventType extends string = string> = Dimensions & {
+    eventType: TEventType;
+    id: Id;
+    callback: () => void;
+};
+export type HTMLDivElementWithId = HTMLDivElement & Record<typeof INTERSECTION_OBSERVER_ID, string | number>;
+export type HandleDragEventArgs = GridLayoutEvent<'dragmove' | 'dragstart' | 'dragend'>;
+export type HandleResizeEventArgs = GridLayoutEvent<'resizestart' | 'resizeend' | 'resizemove'>;
+export type Id = string | number;
+export type IntersectionObserverConfig = IntersectionObserverInit;

package/dist/components/design/grids/types/grid-item.d.ts

@@ -0,0 +1,45 @@
+import { Ref } from 'vue';
+import { Margin } from './grid-layout';
+import { Breakpoints, BreakpointsKeys } from './helpers';
+import { Dimensions, GridItemPosition, Id } from './components';
+export type GridItemEvents = {
+    nocResizeContainer: [payload: ResizePayload];
+    nocResize: [payload: ResizePayload];
+    nocResizeEnd: [payload: ResizePayload];
+    nocMove: [payload: MovePayload];
+    nocMoveEnd: [payload: MovePayload];
+};
+export interface GridItemProps {
+    breakpointCols: Breakpoints;
+    colNum: number;
+    scale?: number;
+    containerWidth: number;
+    h: number;
+    id: Id;
+    isDraggable: boolean;
+    isResizable: boolean;
+    lastBreakpoint: BreakpointsKeys;
+    margin: Margin;
+    maxRows: number;
+    rowHeight: number;
+    useCssTransforms: boolean;
+    w: number;
+    x: number;
+    y: number;
+    /**
+     * @deprecated
+     * @description Used only for compatibility after deleting mitt
+     */
+    calculateStylesTrigger: Ref<boolean>;
+    dragAllowFrom?: string | null;
+    dragIgnoreFrom?: string;
+    dragOption?: object;
+    maxH?: number;
+    maxW?: number;
+    minH?: number;
+    minW?: number;
+    observer?: IntersectionObserver | undefined;
+    isStatic?: boolean;
+}
+export type MovePayload = Pick<Dimensions, 'x' | 'y'> & Record<'id', Id>;
+export type ResizePayload = Pick<Dimensions, 'h' | 'w'> & Pick<GridItemPosition, 'height' | 'width'> & Record<'id', Id>;

package/dist/components/design/grids/types/grid-layout.d.ts

@@ -0,0 +1,48 @@
+import { GridItemEvents } from './grid-item';
+import { Breakpoints, BreakpointsKeys, Layout, ResponsiveLayout } from './helpers';
+import { Dimensions, HandleDragEventArgs, HandleResizeEventArgs, Id, IntersectionObserverConfig } from './components';
+type LayoutEventKey = 'nocLayoutBeforeMount' | 'nocLayoutCreate' | 'nocLayoutMount' | 'nocLayoutReady' | 'nocLayoutUpdate';
+type VModelEvents = {
+    'update:layout': [layout: Layout];
+    'update:breakpoints': [breakpoints: BreakpointsKeys];
+};
+type LayoutEvents = {
+    [Key in LayoutEventKey]: [layout: Layout];
+};
+export type CompleteMargins = [number, number];
+export type GridItemPlaceholder = Dimensions & Record<'id', Id>;
+export type GridLayoutEvents = Pick<GridItemEvents, 'nocResizeContainer'> & // Already in camelCase
+LayoutEvents & VModelEvents & {
+    nocIntersectionObserve: [id: Id[]];
+    nocIntersectionUnobserve: [id: Id[]];
+    nocItemMove: GridItemEvents['nocMove'];
+    nocItemMoveEnd: GridItemEvents['nocMoveEnd'];
+    nocItemResize: GridItemEvents['nocResize'];
+    nocItemResizeEnd: GridItemEvents['nocResizeEnd'];
+};
+export interface GridLayoutProps {
+    colNum: number;
+    layout: Layout;
+    autoSize?: boolean;
+    breakpoints?: Breakpoints;
+    cols?: Breakpoints;
+    horizontalShift?: boolean;
+    intersectionObserverConfig?: IntersectionObserverConfig;
+    isDraggable?: boolean;
+    isResizable?: boolean;
+    margin?: Margin;
+    maxRows?: number;
+    preventCollision?: boolean;
+    responsive?: boolean;
+    responsiveLayouts?: ResponsiveLayout;
+    rowHeight?: number;
+    useCssTransforms?: boolean;
+    useObserver?: boolean;
+    verticalCompact?: boolean;
+}
+export interface GridProvidedValues {
+    handleDragEvent: (args: HandleDragEventArgs) => void;
+    handleResizeEvent: (args: HandleResizeEventArgs) => void;
+}
+export type Margin = [number] | CompleteMargins;
+export {};

package/dist/components/design/grids/types/helpers.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var MovingDirections = /* @__PURE__ */ ((MovingDirections2) => {
+  MovingDirections2["DOWN"] = "DOWN";
+  MovingDirections2["LEFT"] = "LEFT";
+  MovingDirections2["RIGHT"] = "RIGHT";
+  MovingDirections2["UP"] = "UP";
+  return MovingDirections2;
+})(MovingDirections || {});
+exports.MovingDirections = MovingDirections;

package/dist/components/design/grids/types/helpers.d.ts

@@ -0,0 +1,33 @@
+import { Id } from './components';
+export type Breakpoints = RecordBreakpoint<number>;
+export type BreakpointsKeys = 'lg' | 'md' | 'sm' | 'xs' | 'xxs' | '';
+export type Layout = LayoutItem[];
+export type LayoutItem = LayoutItemRequired & LayoutItemOptional;
+export interface LayoutItemOptional {
+    minW?: number;
+    minH?: number;
+    maxW?: number;
+    maxH?: number;
+    moved?: boolean;
+    isStatic?: boolean;
+    isDraggable?: boolean;
+    isResizable?: boolean;
+}
+export interface LayoutItemRequired {
+    w: number;
+    h: number;
+    x: number;
+    y: number;
+    id: Id;
+}
+export type MovingDirection = keyof typeof MovingDirections;
+export declare enum MovingDirections {
+    DOWN = "DOWN",
+    LEFT = "LEFT",
+    RIGHT = "RIGHT",
+    UP = "UP"
+}
+export type RecordBreakpoint<Type> = Partial<Record<BreakpointsKeys, Type>>;
+export type ResponsiveLayout = RecordBreakpoint<Layout>;
+export type findOrGenerateResponsiveLayoutFnc = (orgLayout: Layout, layouts: ResponsiveLayout, breakpoints: Breakpoints, breakpoint: BreakpointsKeys, lastBreakpoint: BreakpointsKeys, cols: number, verticalCompact: boolean) => Layout;
+export type setPositionFnc<Position> = (top: number, left: number, width: number, height: number) => Position;

package/dist/components/design/grids/types/helpers.js

@@ -0,0 +1,10 @@
+var MovingDirections = /* @__PURE__ */ ((MovingDirections2) => {
+  MovingDirections2["DOWN"] = "DOWN";
+  MovingDirections2["LEFT"] = "LEFT";
+  MovingDirections2["RIGHT"] = "RIGHT";
+  MovingDirections2["UP"] = "UP";
+  return MovingDirections2;
+})(MovingDirections || {});
+export {
+  MovingDirections
+};

package/dist/components/design/grids/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './components';
+export * from './grid-item';
+export * from './grid-layout';
+export * from './helpers';