@cube-dev/ui-kit 0.158.0 → 0.160.0

package/dist/components/layout/Board/grid-core/group-move.js.map

@@ -1 +1 @@
-{"version":3,"file":"group-move.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/group-move.ts"],"sourcesContent":["/**\n * Rigid multi-item movement.\n *\n * `moveElement` (see ./layout.ts) moves exactly one item and is free to displace\n * any other item — including one the caller also wanted to move — as a collision\n * victim. That makes it unusable for moving a *selection* as a block: the shape\n * of the group would be destroyed by the very collision resolution meant to make\n * room for it.\n *\n * `moveElements` moves a set of items rigidly instead. Every mover receives the\n * same `(dx, dy)`, so the group's shape is invariant *by construction* rather\n * than by repair — and the compaction that follows is ordered so it cannot\n * undo that (see `compactWithGroupOrder`).\n *\n * This module is UI-Kit-specific; it is not part of the vendored react-grid-layout\n * core (see ./NOTICE.md).\n */\n\nimport { collides, getFirstCollision } from './collision';\nimport { compactItemHorizontal, compactItemVertical } from './compactors';\nimport { bottom, cloneLayout, cloneLayoutItem, getStatics } from './layout';\nimport { sortLayoutItemsByColRow, sortLayoutItemsByRowCol } from './sort';\n\nimport type { Compactor, Layout, LayoutItem, Mutable } from './types';\n\nexport interface MoveElementsOptions {\n  /**\n   * The board's compactor. Supplies `type`, `allowOverlap` and\n   * `preventCollision` as one consistent unit, and performs the tidy-up pass —\n   * taking it whole is what keeps this function from ever disagreeing with the\n   * board about compaction mode.\n   */\n  compactor: Compactor;\n  cols: number;\n  /** @default Infinity */\n  maxRows?: number;\n}\n\nexport interface MoveElementsResult {\n  layout: LayoutItem[];\n  /** The delta actually applied, after clamping the group to the grid. */\n  dx: number;\n  dy: number;\n  /**\n   * Whether a valid arrangement was produced. `false` means the frame must be\n   * discarded and the previous one kept — never partially applied, since a\n   * partial delta is precisely what shears the group apart.\n   */\n  moved: boolean;\n}\n\n/** An item may be moved unless it is static and does not opt back in. */\nfunction isMovable(item: LayoutItem): boolean {\n  return !item.static || item.isDraggable === true;\n}\n\n/**\n * Move every item in `ids` by the same delta, resolving collisions with the\n * items that are *not* moving.\n *\n * Semantics, all deliberate:\n *\n * - **Group-clamped, not item-clamped.** The delta is clamped once against the\n *   whole group, so dragging into an edge parks the block against it. Clamping\n *   each item into bounds separately would collapse the group's shape the first\n *   time it touched a wall, and it would never recover.\n * - **All-or-nothing.** If the frame cannot be resolved, nothing moves.\n * - **Movers never collide with each other.** They keep their relative\n *   positions, so only mover↔non-mover and non-mover↔non-mover overlaps resolve.\n * - **A static item is never a mover**, matching `moveElement`'s own guard, and\n *   a mover can never displace a static item — that frame is rejected instead.\n * - **Gravity still wins, but it cannot reach inside the group.** A compacting\n *   board reflows the movers along with everyone else, so the block is not held\n *   in mid-air; the group is merely compacted as one consecutive run, which is\n *   what stops a displaced neighbour being packed *between* two members.\n *\n * Returns a new layout in the input's item order; the input is never mutated.\n */\nexport function moveElements(\n  layout: Layout,\n  ids: ReadonlySet<string>,\n  dx: number,\n  dy: number,\n  options: MoveElementsOptions,\n): MoveElementsResult {\n  const { compactor, cols, maxRows = Infinity } = options;\n\n  const working = cloneLayout(layout);\n  const movers = working.filter((it) => ids.has(it.i) && isMovable(it));\n\n  if (movers.length === 0) {\n    return { layout: working, dx: 0, dy: 0, moved: false };\n  }\n\n  const moverIds = new Set(movers.map((it) => it.i));\n  const others = working.filter((it) => !moverIds.has(it.i));\n\n  // ---- Clamp the delta to the group ----------------------------------------\n  //\n  // The group can travel until its *first* item hits an edge. `Math.max` on the\n  // upper bounds guards the degenerate case of an item wider/taller than the\n  // grid, where the max would otherwise fall below the min and invert the range.\n  let minDx = -Infinity;\n  let maxDx = Infinity;\n  let minDy = -Infinity;\n  let maxDy = Infinity;\n\n  for (const it of movers) {\n    minDx = Math.max(minDx, -it.x);\n    maxDx = Math.min(maxDx, cols - it.w - it.x);\n    minDy = Math.max(minDy, -it.y);\n    maxDy = Math.min(maxDy, maxRows - it.h - it.y);\n  }\n  maxDx = Math.max(minDx, maxDx);\n  maxDy = Math.max(minDy, maxDy);\n\n  // `|| 0` collapses `-0`, which `Math.max` produces whenever a mover sits at\n  // coordinate 0. It compares equal to `0` but not under `Object.is`, and it\n  // would otherwise be handed back to callers as a delta.\n  const clampedDx = Math.min(Math.max(dx, minDx), maxDx) || 0;\n  const clampedDy = Math.min(Math.max(dy, minDy), maxDy) || 0;\n\n  for (const it of movers) {\n    (it as Mutable<LayoutItem>).x = it.x + clampedDx;\n    (it as Mutable<LayoutItem>).y = it.y + clampedDy;\n  }\n\n  const rejected: MoveElementsResult = {\n    layout: cloneLayout(layout),\n    dx: 0,\n    dy: 0,\n    moved: false,\n  };\n\n  if (!compactor.allowOverlap) {\n    // A static non-mover cannot be pushed out of the way, so overlapping one is\n    // never resolvable.\n    for (const it of others) {\n      if (it.static && getFirstCollision(movers, it)) {\n        return rejected;\n      }\n    }\n\n    if (compactor.preventCollision) {\n      // `compact=\"free\"` / legacy no-compaction with collisions prevented: the\n      // group may only land where it fits outright.\n      for (const it of movers) {\n        if (getFirstCollision(others, it)) {\n          return rejected;\n        }\n      }\n    } else if (compactor.type === null && !pushOthersDown(movers, others)) {\n      // Only when nothing else will: a compacting compactor resolves overlaps\n      // itself (and floats items back up afterwards), so pre-pushing there just\n      // shoves neighbours further than needed and makes the board look like it\n      // is lagging a step behind the pointer.\n      return rejected;\n    }\n  }\n\n  // Compact exactly as the single-widget path does — the group is not held in\n  // place. On a vertically-compacted board a lone widget can never be parked in\n  // empty space, and a group must not be able to either: neighbours have to\n  // close the gap the moment it opens, or the board reads as a step behind.\n  //\n  // But *order* the pass so the group stays one run. A plain compaction sorts\n  // every item by `(y, x)` and packs each one independently, with no idea a\n  // group exists — so the moment movers and non-movers interleave in y, a\n  // displaced neighbour gets packed between two members and the selection comes\n  // apart mid-drag. Check `allowOverlap` first: the overlap compactors report a\n  // `type` but their `compact` is a plain clone, so there is nothing to order.\n  const groupAware =\n    !compactor.allowOverlap &&\n    (compactor.type === 'vertical' || compactor.type === 'horizontal');\n\n  const out = groupAware\n    ? compactWithGroupOrder(working, moverIds, {\n        axis: compactor.type as CompactionAxis,\n        travel: compactor.type === 'horizontal' ? clampedDx : clampedDy,\n        cols,\n      })\n    : [...compactor.compact(working, cols)];\n\n  return { layout: out, dx: clampedDx, dy: clampedDy, moved: true };\n}\n\ntype CompactionAxis = 'vertical' | 'horizontal';\n\ninterface GroupOrderOptions {\n  /** The axis the board compacts along. */\n  axis: CompactionAxis;\n  /**\n   * The group's clamped travel along that axis. Only the sign is read — it\n   * decides who wins a tie for the same row (or column).\n   */\n  travel: number;\n  cols: number;\n}\n\n/** A group of movers, or a single non-mover, as one thing to place. */\ninterface CompactionUnit {\n  isGroup: boolean;\n  /** Leading edge along the compaction axis. */\n  head: number;\n  /** Leading edge across it, among the members sitting at `head`. */\n  cross: number;\n  members: LayoutItem[];\n}\n\n/**\n * Compact a layout the way the board's own compactor would, except that the\n * movers are placed as one consecutive run instead of being interleaved with\n * everyone else by a global `(y, x)` sort.\n *\n * Each member still floats individually under gravity, so the result is a fixed\n * point of the plain compactor — nothing is parked in mid-air, and a later\n * unrelated drag (which re-compacts the whole board) cannot shear the group\n * after the fact. The single invariant this adds is that a non-mover can never\n * end up *between* two members.\n *\n * Placement order decides everything, and it turns on the direction of travel:\n *\n * - Moving **against** gravity (`travel < 0`), the group claims the row it was\n *   dropped on and the widgets it passed fall in below it.\n * - Moving **with** gravity, the non-movers close the vacated space first.\n *   Handing the group the tie here would leave it exactly where it started and\n *   the drag would read as a no-op.\n *\n * The comparison is a strict `travel < 0`, so a zero-travel re-run lands in the\n * second branch — that is what makes the pass idempotent, which the live drag\n * and the keyboard path both depend on.\n */\nfunction compactWithGroupOrder(\n  layout: Layout,\n  moverIds: ReadonlySet<string>,\n  { axis, travel, cols }: GroupOrderOptions,\n): LayoutItem[] {\n  const horizontal = axis === 'horizontal';\n  const head = horizontal ? 'x' : 'y';\n  const cross = horizontal ? 'y' : 'x';\n  const groupFirst = travel < 0;\n\n  const clones = layout.map(cloneLayoutItem);\n  const movers: LayoutItem[] = [];\n  const units: CompactionUnit[] = [];\n\n  for (const it of clones) {\n    if (moverIds.has(it.i)) {\n      movers.push(it);\n    } else {\n      units.push({\n        isGroup: false,\n        head: it[head],\n        cross: it[cross],\n        members: [it],\n      });\n    }\n  }\n\n  if (movers.length > 0) {\n    const groupHead = Math.min(...movers.map((it) => it[head]));\n\n    units.push({\n      isGroup: true,\n      head: groupHead,\n      cross: Math.min(\n        ...movers.filter((it) => it[head] === groupHead).map((it) => it[cross]),\n      ),\n      // Members are placed in the same reading order the compactor would have\n      // used, so within the run each one lands exactly where it would have.\n      members: horizontal\n        ? sortLayoutItemsByColRow(movers)\n        : sortLayoutItemsByRowCol(movers),\n    });\n  }\n\n  units.sort((a, b) => {\n    if (a.head !== b.head) return a.head - b.head;\n    // Same row: direction decides whether the group or the displaced non-movers\n    // get first claim on it.\n    if (a.isGroup !== b.isGroup) return a.isGroup === groupFirst ? -1 : 1;\n    if (a.cross !== b.cross) return a.cross - b.cross;\n\n    return 0;\n  });\n\n  // From here on this mirrors `verticalCompactor` / `horizontalCompactor`\n  // exactly: statics seed the obstacle set and are never floated, every other\n  // item is packed against what is already placed, and `maxY` tracks how far\n  // down the board has filled.\n  const order = units.flatMap((unit) => unit.members);\n  const compareWith = getStatics(clones);\n  let maxY = bottom(compareWith);\n\n  for (const l of order) {\n    if (!l.static) {\n      if (horizontal) {\n        compactItemHorizontal(compareWith, l, cols, order);\n      } else {\n        compactItemVertical(compareWith, l, order, maxY);\n        maxY = Math.max(maxY, l.y + l.h);\n      }\n      compareWith.push(l);\n    }\n    l.moved = false;\n  }\n\n  return clones;\n}\n\n/**\n * Push every non-mover that overlaps the group (or another displaced item)\n * straight down until nothing overlaps.\n *\n * Down, always — even under horizontal compaction. Downward is the one direction\n * a grid always has room in, so the pass is guaranteed to terminate; the\n * compactor then re-packs along its own axis immediately afterwards. Pushing\n * sideways would need overflow wrapping here and could ping-pong an item between\n * two neighbours.\n *\n * Mutates `others` in place. Returns `false` if the cascade fails to settle,\n * which the caller turns into a rejected frame.\n */\nfunction pushOthersDown(movers: LayoutItem[], others: LayoutItem[]): boolean {\n  // Place one at a time, in reading order, against a set that starts as the\n  // group. Each push moves an item strictly past a placed item's bottom edge, so\n  // it advances monotonically and the loop is bounded by the stack height.\n  const ordered = [...others].sort((a, b) =>\n    a.y === b.y ? a.x - b.x : a.y - b.y,\n  );\n  const placed: LayoutItem[] = [...movers];\n  const limit = bottom(movers) + bottom(others) + others.length + 1;\n\n  for (const item of ordered) {\n    if (item.static) {\n      // Verified collision-free against the movers by the caller; other statics\n      // are pre-existing and not ours to resolve.\n      placed.push(item);\n      continue;\n    }\n\n    let steps = 0;\n    let shifted = true;\n\n    while (shifted) {\n      shifted = false;\n      for (const other of placed) {\n        if (collides(item, other)) {\n          (item as Mutable<LayoutItem>).y = other.y + other.h;\n          shifted = true;\n        }\n      }\n      if (++steps > limit) {\n        return false;\n      }\n    }\n\n    placed.push(item);\n  }\n\n  return true;\n}\n"],"mappings":"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"}
+{"version":3,"file":"group-move.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/group-move.ts"],"sourcesContent":["/**\n * Rigid multi-item movement.\n *\n * `moveElement` (see ./layout.ts) moves exactly one item and is free to displace\n * any other item — including one the caller also wanted to move — as a collision\n * victim. That makes it unusable for moving a *selection* as a block: the shape\n * of the group would be destroyed by the very collision resolution meant to make\n * room for it.\n *\n * `moveElements` moves a set of items rigidly instead. Every mover receives the\n * same `(dx, dy)`, so the group's shape is invariant *by construction* rather\n * than by repair — and the compaction that follows both orders and places the\n * group as one block, so it cannot undo that (see `compactWithGroupOrder`).\n *\n * This module is UI-Kit-specific; it is not part of the vendored react-grid-layout\n * core (see ./NOTICE.md).\n */\n\nimport { collides, getFirstCollision } from './collision';\nimport { compactItemHorizontal, compactItemVertical } from './compactors';\nimport { bottom, cloneLayout, cloneLayoutItem, getStatics } from './layout';\nimport { sortLayoutItemsByColRow, sortLayoutItemsByRowCol } from './sort';\n\nimport type { Compactor, Layout, LayoutItem, Mutable } from './types';\n\nexport interface MoveElementsOptions {\n  /**\n   * The board's compactor. Supplies `type`, `allowOverlap` and\n   * `preventCollision` as one consistent unit, and performs the tidy-up pass —\n   * taking it whole is what keeps this function from ever disagreeing with the\n   * board about compaction mode.\n   */\n  compactor: Compactor;\n  cols: number;\n  /** @default Infinity */\n  maxRows?: number;\n}\n\nexport interface MoveElementsResult {\n  layout: LayoutItem[];\n  /** The delta actually applied, after clamping the group to the grid. */\n  dx: number;\n  dy: number;\n  /**\n   * Whether a valid arrangement was produced. `false` means the frame must be\n   * discarded and the previous one kept — never partially applied, since a\n   * partial delta is precisely what shears the group apart.\n   */\n  moved: boolean;\n}\n\n/** An item may be moved unless it is static and does not opt back in. */\nfunction isMovable(item: LayoutItem): boolean {\n  return !item.static || item.isDraggable === true;\n}\n\n/**\n * Move every item in `ids` by the same delta, resolving collisions with the\n * items that are *not* moving.\n *\n * Semantics, all deliberate:\n *\n * - **Group-clamped, not item-clamped.** The delta is clamped once against the\n *   whole group, so dragging into an edge parks the block against it. Clamping\n *   each item into bounds separately would collapse the group's shape the first\n *   time it touched a wall, and it would never recover.\n * - **All-or-nothing.** If the frame cannot be resolved, nothing moves.\n * - **Movers never collide with each other.** They keep their relative\n *   positions, so only mover↔non-mover and non-mover↔non-mover overlaps resolve.\n * - **A static item is never a mover**, matching `moveElement`'s own guard, and\n *   a mover can never displace a static item — that frame is rejected instead.\n * - **Gravity still wins, but it cannot reach inside the group.** A compacting\n *   board floats the block along with everyone else, so it is not held in\n *   mid-air; it just floats as *one rigid unit*, which is what stops a\n *   displaced neighbour being packed between two members or one member being\n *   floated out from under another.\n *\n * Returns a new layout in the input's item order; the input is never mutated.\n */\nexport function moveElements(\n  layout: Layout,\n  ids: ReadonlySet<string>,\n  dx: number,\n  dy: number,\n  options: MoveElementsOptions,\n): MoveElementsResult {\n  const { compactor, cols, maxRows = Infinity } = options;\n\n  const working = cloneLayout(layout);\n  const movers = working.filter((it) => ids.has(it.i) && isMovable(it));\n\n  if (movers.length === 0) {\n    return { layout: working, dx: 0, dy: 0, moved: false };\n  }\n\n  const moverIds = new Set(movers.map((it) => it.i));\n  const others = working.filter((it) => !moverIds.has(it.i));\n\n  // ---- Clamp the delta to the group ----------------------------------------\n  //\n  // The group can travel until its *first* item hits an edge. `Math.max` on the\n  // upper bounds guards the degenerate case of an item wider/taller than the\n  // grid, where the max would otherwise fall below the min and invert the range.\n  let minDx = -Infinity;\n  let maxDx = Infinity;\n  let minDy = -Infinity;\n  let maxDy = Infinity;\n\n  for (const it of movers) {\n    minDx = Math.max(minDx, -it.x);\n    maxDx = Math.min(maxDx, cols - it.w - it.x);\n    minDy = Math.max(minDy, -it.y);\n    maxDy = Math.min(maxDy, maxRows - it.h - it.y);\n  }\n  maxDx = Math.max(minDx, maxDx);\n  maxDy = Math.max(minDy, maxDy);\n\n  // `|| 0` collapses `-0`, which `Math.max` produces whenever a mover sits at\n  // coordinate 0. It compares equal to `0` but not under `Object.is`, and it\n  // would otherwise be handed back to callers as a delta.\n  const clampedDx = Math.min(Math.max(dx, minDx), maxDx) || 0;\n  const clampedDy = Math.min(Math.max(dy, minDy), maxDy) || 0;\n\n  for (const it of movers) {\n    (it as Mutable<LayoutItem>).x = it.x + clampedDx;\n    (it as Mutable<LayoutItem>).y = it.y + clampedDy;\n  }\n\n  const rejected: MoveElementsResult = {\n    layout: cloneLayout(layout),\n    dx: 0,\n    dy: 0,\n    moved: false,\n  };\n\n  // The axis the board compacts along; `null` has none, but its pre-push has to\n  // pick a direction and down is the one a grid always has room in.\n  const axis: 'x' | 'y' = compactor.type === 'horizontal' ? 'x' : 'y';\n  const travel = axis === 'x' ? clampedDx : clampedDy;\n  const drift = axis === 'x' ? clampedDy : clampedDx;\n  /**\n   * Whether the group is taking ground rather than giving it up — the question\n   * that decides who has to move aside.\n   *\n   * Only a move *along* the compaction axis gives ground up: the group leaves\n   * rows behind it, and the widgets below fall into them. Moving against the\n   * axis, or purely *across* it, takes ground instead: every cell the group\n   * lands on has to be vacated for it.\n   */\n  const takesGround = travel < 0 || (travel === 0 && drift !== 0);\n\n  if (!compactor.allowOverlap) {\n    // A static non-mover cannot be pushed out of the way, so overlapping one is\n    // never resolvable.\n    for (const it of others) {\n      if (it.static && getFirstCollision(movers, it)) {\n        return rejected;\n      }\n    }\n\n    if (compactor.preventCollision) {\n      // `compact=\"free\"` / legacy no-compaction with collisions prevented: the\n      // group may only land where it fits outright.\n      for (const it of movers) {\n        if (getFirstCollision(others, it)) {\n          return rejected;\n        }\n      }\n    } else if (\n      compactor.type === null ||\n      ((compactor.type === 'vertical' || compactor.type === 'horizontal') &&\n        takesGround)\n    ) {\n      // Nothing else will resolve it:\n      //\n      // - `type === null` has no compaction pass at all.\n      // - Whenever the group *takes* ground, the widgets standing on it have to\n      //   be moved off first. Compaction alone cannot do that: it places items\n      //   in `head` order, so a non-mover on the group's landing row is placed\n      //   first and then blocks it. Against the axis the group stops short (or\n      //   does not move at all) while the widgets it did overlap slide down —\n      //   the \"only some of them moved\" symptom. Across the axis it is worse:\n      //   the group is the one gravity shoves aside, so dragging a pair\n      //   sideways slides *it* down under the widgets it was supposed to\n      //   displace, and they look pinned in place.\n      //\n      //   Displacing first is what the single-widget path does too\n      //   (`moveElementAwayFromCollision` runs before compaction), and it costs\n      //   nothing extra: `compactWithGroupOrder` reads each unit's `head` from\n      //   these updated coordinates, so the pushed items sort after the group\n      //   and gravity floats them straight back to their minimal positions in\n      //   the same frame.\n      //\n      // Giving ground up needs the opposite: the non-movers must claim the\n      // vacated rows first, or the group lands back where it started and the\n      // drag reads as a no-op.\n      if (!displaceOthers(movers, others, axis)) {\n        return rejected;\n      }\n    }\n  }\n\n  // Compact exactly as the single-widget path does — the group is not held in\n  // place. On a vertically-compacted board a lone widget can never be parked in\n  // empty space, and a group must not be able to either: neighbours have to\n  // close the gap the moment it opens, or the board reads as a step behind.\n  //\n  // But the group is placed as *one block*. A plain compaction sorts every item\n  // by `(y, x)` and packs each one independently, with no idea a group exists —\n  // so a displaced neighbour gets packed between two members, or one member\n  // floats out from under another and the selection comes apart mid-drag. Check\n  // `allowOverlap` first: the overlap compactors report a `type` but their\n  // `compact` is a plain clone, so there is nothing to order.\n  const groupAware =\n    !compactor.allowOverlap &&\n    (compactor.type === 'vertical' || compactor.type === 'horizontal');\n\n  const out = groupAware\n    ? compactWithGroupOrder(working, moverIds, {\n        axis: compactor.type as CompactionAxis,\n        travel,\n        cols,\n      })\n    : [...compactor.compact(working, cols)];\n\n  return { layout: out, dx: clampedDx, dy: clampedDy, moved: true };\n}\n\ntype CompactionAxis = 'vertical' | 'horizontal';\n\ninterface GroupOrderOptions {\n  /** The axis the board compacts along. */\n  axis: CompactionAxis;\n  /**\n   * The group's clamped travel along that axis. Only the sign is read — it\n   * decides who wins a tie for the same row (or column).\n   */\n  travel: number;\n  cols: number;\n}\n\n/** A group of movers, or a single non-mover, as one thing to place. */\ninterface CompactionUnit {\n  isGroup: boolean;\n  /** Leading edge along the compaction axis. */\n  head: number;\n  /** Leading edge across it, among the members sitting at `head`. */\n  cross: number;\n  members: LayoutItem[];\n  /**\n   * Where the members sat before *anything* was placed, in `members` order.\n   *\n   * The group's shape has to be read from here rather than from the live items:\n   * packing a non-mover runs `resolveCompactionCollision`, which shoves items\n   * later in the placement order out of its way — and for any drag where the\n   * group is placed after a non-mover, that cascade reaches inside the group and\n   * moves one member without the others. Left alone it would be baked into the\n   * block as if it were the shape the user is holding, and two members can end\n   * up on top of each other.\n   */\n  origin?: Array<{ x: number; y: number }>;\n}\n\n/**\n * Compact a layout the way the board's own compactor would, except that the\n * movers are placed as one rigid block instead of being packed one by one by a\n * global `(y, x)` sort.\n *\n * The block still floats under gravity — it is never parked in mid-air — but it\n * floats as a unit: one shift is applied to every member, so relative offsets\n * are invariant for the whole drag. Nothing can be packed between two members,\n * and no member can float out from under another.\n *\n * The cost, deliberately accepted: a *ragged* group (one whose members could\n * individually float further) is no longer a fixed point of the plain compactor,\n * so the drop — which re-compacts the source board — settles it. Holding the\n * shape while the pointer is down is what the gesture is about; the resting\n * layout stays an ordinary compacted layout.\n *\n * Placement order decides everything, and it turns on the direction of travel:\n *\n * - Moving **against** gravity (`travel < 0`), the group claims the row it was\n *   dropped on and the widgets it passed fall in below it.\n * - Moving **with** gravity, the non-movers close the vacated space first.\n *   Handing the group the tie here would leave it exactly where it started and\n *   the drag would read as a no-op.\n *\n * The comparison is a strict `travel < 0`, so a zero-travel re-run lands in the\n * second branch — that is what makes the pass idempotent, which the live drag\n * and the keyboard path both depend on.\n */\nfunction compactWithGroupOrder(\n  layout: Layout,\n  moverIds: ReadonlySet<string>,\n  { axis, travel, cols }: GroupOrderOptions,\n): LayoutItem[] {\n  const horizontal = axis === 'horizontal';\n  const head = horizontal ? 'x' : 'y';\n  const cross = horizontal ? 'y' : 'x';\n  const groupFirst = travel < 0;\n\n  const clones = layout.map(cloneLayoutItem);\n  const movers: LayoutItem[] = [];\n  const units: CompactionUnit[] = [];\n\n  for (const it of clones) {\n    if (moverIds.has(it.i)) {\n      movers.push(it);\n    } else {\n      units.push({\n        isGroup: false,\n        head: it[head],\n        cross: it[cross],\n        members: [it],\n      });\n    }\n  }\n\n  if (movers.length > 0) {\n    const groupHead = Math.min(...movers.map((it) => it[head]));\n    // Members are placed in the same reading order the compactor would have\n    // used, so a block that has to fall back to item-by-item packing lands\n    // exactly where it would have.\n    const members = horizontal\n      ? sortLayoutItemsByColRow(movers)\n      : sortLayoutItemsByRowCol(movers);\n\n    units.push({\n      isGroup: true,\n      head: groupHead,\n      cross: Math.min(\n        ...movers.filter((it) => it[head] === groupHead).map((it) => it[cross]),\n      ),\n      members,\n      origin: members.map((it) => ({ x: it.x, y: it.y })),\n    });\n  }\n\n  units.sort((a, b) => {\n    if (a.head !== b.head) return a.head - b.head;\n    // Same row: direction decides whether the group or the displaced non-movers\n    // get first claim on it.\n    if (a.isGroup !== b.isGroup) return a.isGroup === groupFirst ? -1 : 1;\n    if (a.cross !== b.cross) return a.cross - b.cross;\n\n    return 0;\n  });\n\n  // From here on this mirrors `verticalCompactor` / `horizontalCompactor`\n  // exactly: statics seed the obstacle set and are never floated, every other\n  // item is packed against what is already placed, and `maxY` tracks how far\n  // down the board has filled. The one departure is a group of two or more,\n  // which is floated as a block instead of item by item.\n  const order = units.flatMap((unit) => unit.members);\n  const compareWith = getStatics(clones);\n  let maxY = bottom(compareWith);\n\n  for (const unit of units) {\n    const asBlock =\n      unit.isGroup &&\n      unit.members.length > 1 &&\n      unit.origin !== undefined &&\n      placeBlock(compareWith, unit.members, unit.origin, {\n        horizontal,\n        cols,\n        maxHead: horizontal ? Infinity : maxY,\n      });\n\n    // A single mover, a non-mover, or a block that could not be placed in one\n    // piece: pack each item on its own, exactly as the plain compactor would. A\n    // one-item group must stay byte-identical to dragging that widget alone.\n    if (!asBlock) {\n      for (const l of unit.members) {\n        if (!l.static) {\n          if (horizontal) {\n            compactItemHorizontal(compareWith, l, cols, order);\n          } else {\n            compactItemVertical(compareWith, l, order, maxY);\n            maxY = Math.max(maxY, l.y + l.h);\n          }\n          compareWith.push(l);\n        }\n        l.moved = false;\n      }\n      continue;\n    }\n\n    for (const l of unit.members) {\n      compareWith.push(l);\n      if (!horizontal) maxY = Math.max(maxY, l.y + l.h);\n      l.moved = false;\n    }\n  }\n\n  return clones;\n}\n\ninterface PlaceBlockOptions {\n  horizontal: boolean;\n  cols: number;\n  /**\n   * How far the board has filled along the compaction axis. The block's leading\n   * edge is pulled back to it before floating, mirroring `compactItemVertical`'s\n   * `y = Math.min(maxY, y)` — a group dropped far past the end of the board must\n   * not be able to park out there any more than a single widget can.\n   * `Infinity` disables the clamp (the horizontal compactor has no equivalent).\n   */\n  maxHead: number;\n}\n\n/**\n * Float a whole group into place with a single shift, so every member keeps its\n * exact offset from every other.\n *\n * The shape is taken from `origin` — where the members sat before any placement\n * ran — not from their live coordinates, which an earlier unit's collision\n * cascade may already have pulled apart (see `CompactionUnit.origin`).\n *\n * Members are mutated only on success; a failure restores them, which is what\n * lets the caller fall back to packing them individually. Failure is reserved\n * for the one case a block genuinely cannot express: a horizontal board where\n * settling the overlap would push a member past the last column.\n *\n * Returns whether the block was placed.\n */\nfunction placeBlock(\n  compareWith: Layout,\n  members: LayoutItem[],\n  origin: ReadonlyArray<{ x: number; y: number }>,\n  { horizontal, cols, maxHead }: PlaceBlockOptions,\n): boolean {\n  const head = horizontal ? 'x' : 'y';\n  const size = horizontal ? 'w' : 'h';\n\n  const restore = () => {\n    members.forEach((it, index) => {\n      const at = origin[index] as { x: number; y: number };\n      (it as Mutable<LayoutItem>).x = at.x;\n      (it as Mutable<LayoutItem>).y = at.y;\n    });\n  };\n\n  restore();\n\n  const shift = (delta: number) => {\n    for (const it of members) {\n      (it as Mutable<LayoutItem>)[head] += delta;\n    }\n  };\n  const leadingEdge = () => Math.min(...members.map((it) => it[head]));\n  const trailingEdge = () =>\n    Math.max(...members.map((it) => it[head] + it[size]));\n  const overlaps = () =>\n    members.some((it) => getFirstCollision(compareWith, it) !== undefined);\n\n  // Correct the block into the grid, then pull it back to the fill line.\n  if (leadingEdge() < 0) shift(-leadingEdge());\n  const overshoot = leadingEdge() - maxHead;\n  if (overshoot > 0) shift(-overshoot);\n\n  // Float against gravity for as long as the *whole* block is clear one step\n  // earlier. Testing the next position rather than the current one (which is\n  // how `compactItemVertical` is written) matters here: a block can straddle\n  // several rows, so stepping into an overlap and unwinding it afterwards would\n  // let the settle loop below carry it past where it should have stopped.\n  while (leadingEdge() > 0) {\n    shift(-1);\n    if (overlaps()) {\n      shift(1);\n      break;\n    }\n  }\n\n  if (!overlaps()) {\n    // Clear where it floated to — as long as it is still on the grid. Only the\n    // horizontal axis can fail that: `cols` bounds it, and the delta clamp has\n    // already guaranteed every member fits before this ran.\n    if (!horizontal || trailingEdge() <= cols) return true;\n    restore();\n\n    return false;\n  }\n\n  // Landed on something already placed — push the block forward until it is\n  // clear. Bounded by how far the placed items reach plus the block's own\n  // extent, so an unresolvable frame cannot spin.\n  const span = members.reduce((total, it) => total + it[size], 0);\n  const limit =\n    Math.max(0, ...compareWith.map((it) => it[head] + it[size])) +\n    span +\n    members.length +\n    1;\n\n  for (let step = 0; step < limit; step++) {\n    shift(1);\n    if (horizontal && trailingEdge() > cols) {\n      restore();\n      return false;\n    }\n    if (!overlaps()) return true;\n  }\n\n  restore();\n  return false;\n}\n\n/**\n * Push every non-mover that overlaps the group (or another displaced item) past\n * it along `axis`, until nothing overlaps.\n *\n * `axis` is the board's compaction axis, so the compactor re-packs along the same\n * line immediately afterwards and pulls each displaced item back to its minimal\n * position. A board that does not compact at all (`compact=\"free\"`) is pushed\n * down: down is the one direction a grid always has room in.\n *\n * Pushing along `x` can carry an item past the last column. That is fine and\n * deliberate: `compactItemHorizontal` wraps an overflowing item to the next row,\n * which is a resolution — rejecting the frame here instead would freeze better\n * than a quarter of all leftward group drags.\n *\n * Mutates `others` in place. Returns `false` if the cascade fails to settle,\n * which the caller turns into a rejected frame.\n */\nfunction displaceOthers(\n  movers: LayoutItem[],\n  others: LayoutItem[],\n  axis: 'x' | 'y',\n): boolean {\n  const size = axis === 'x' ? 'w' : 'h';\n  // Place one at a time, in reading order, against a set that starts as the\n  // group. Each push moves an item strictly past a placed item's far edge, so it\n  // advances monotonically and the loop is bounded by the stack extent.\n  const ordered = [...others].sort((a, b) =>\n    a.y === b.y ? a.x - b.x : a.y - b.y,\n  );\n  const placed: LayoutItem[] = [...movers];\n  const reach = (items: LayoutItem[]) =>\n    Math.max(0, ...items.map((it) => it[axis] + it[size]));\n  const limit = reach(movers) + reach(others) + others.length + 1;\n\n  for (const item of ordered) {\n    if (item.static) {\n      // Verified collision-free against the movers by the caller; other statics\n      // are pre-existing and not ours to resolve.\n      placed.push(item);\n      continue;\n    }\n\n    let steps = 0;\n    let shifted = true;\n\n    while (shifted) {\n      shifted = false;\n      for (const other of placed) {\n        if (collides(item, other)) {\n          (item as Mutable<LayoutItem>)[axis] = other[axis] + other[size];\n          shifted = true;\n        }\n      }\n      if (++steps > limit) {\n        return false;\n      }\n    }\n\n    placed.push(item);\n  }\n\n  return true;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,SAAS,UAAU,MAA2B;AAC5C,QAAO,CAAC,KAAK,UAAU,KAAK,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;AA0B9C,SAAgB,aACd,QACA,KACA,IACA,IACA,SACoB;CACpB,MAAM,EAAE,WAAW,MAAM,UAAU,aAAa;CAEhD,MAAM,UAAU,YAAY,OAAO;CACnC,MAAM,SAAS,QAAQ,QAAQ,OAAO,IAAI,IAAI,GAAG,EAAE,IAAI,UAAU,GAAG,CAAC;AAErE,KAAI,OAAO,WAAW,EACpB,QAAO;EAAE,QAAQ;EAAS,IAAI;EAAG,IAAI;EAAG,OAAO;EAAO;CAGxD,MAAM,WAAW,IAAI,IAAI,OAAO,KAAK,OAAO,GAAG,EAAE,CAAC;CAClD,MAAM,SAAS,QAAQ,QAAQ,OAAO,CAAC,SAAS,IAAI,GAAG,EAAE,CAAC;CAO1D,IAAI,QAAQ;CACZ,IAAI,QAAQ;CACZ,IAAI,QAAQ;CACZ,IAAI,QAAQ;AAEZ,MAAK,MAAM,MAAM,QAAQ;AACvB,UAAQ,KAAK,IAAI,OAAO,CAAC,GAAG,EAAE;AAC9B,UAAQ,KAAK,IAAI,OAAO,OAAO,GAAG,IAAI,GAAG,EAAE;AAC3C,UAAQ,KAAK,IAAI,OAAO,CAAC,GAAG,EAAE;AAC9B,UAAQ,KAAK,IAAI,OAAO,UAAU,GAAG,IAAI,GAAG,EAAE;;AAEhD,SAAQ,KAAK,IAAI,OAAO,MAAM;AAC9B,SAAQ,KAAK,IAAI,OAAO,MAAM;CAK9B,MAAM,YAAY,KAAK,IAAI,KAAK,IAAI,IAAI,MAAM,EAAE,MAAM,IAAI;CAC1D,MAAM,YAAY,KAAK,IAAI,KAAK,IAAI,IAAI,MAAM,EAAE,MAAM,IAAI;AAE1D,MAAK,MAAM,MAAM,QAAQ;AACvB,EAAC,GAA2B,IAAI,GAAG,IAAI;AACvC,EAAC,GAA2B,IAAI,GAAG,IAAI;;CAGzC,MAAM,WAA+B;EACnC,QAAQ,YAAY,OAAO;EAC3B,IAAI;EACJ,IAAI;EACJ,OAAO;EACR;CAID,MAAM,OAAkB,UAAU,SAAS,eAAe,MAAM;CAChE,MAAM,SAAS,SAAS,MAAM,YAAY;;;;;;;;;;CAW1C,MAAM,cAAc,SAAS,KAAM,WAAW,MAVhC,SAAS,MAAM,YAAY,eAUoB;AAE7D,KAAI,CAAC,UAAU,cAAc;AAG3B,OAAK,MAAM,MAAM,OACf,KAAI,GAAG,UAAU,kBAAkB,QAAQ,GAAG,CAC5C,QAAO;AAIX,MAAI,UAAU,kBAGZ;QAAK,MAAM,MAAM,OACf,KAAI,kBAAkB,QAAQ,GAAG,CAC/B,QAAO;aAIX,UAAU,SAAS,SACjB,UAAU,SAAS,cAAc,UAAU,SAAS,iBACpD,aAyBF;OAAI,CAAC,eAAe,QAAQ,QAAQ,KAAK,CACvC,QAAO;;;AA4Bb,QAAO;EAAE,QAXP,CAAC,UAAU,iBACV,UAAU,SAAS,cAAc,UAAU,SAAS,gBAGnD,sBAAsB,SAAS,UAAU;GACvC,MAAM,UAAU;GAChB;GACA;GACD,CAAC,GACF,CAAC,GAAG,UAAU,QAAQ,SAAS,KAAK,CAAC;EAEnB,IAAI;EAAW,IAAI;EAAW,OAAO;EAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEnE,SAAS,sBACP,QACA,UACA,EAAE,MAAM,QAAQ,QACF;CACd,MAAM,aAAa,SAAS;CAC5B,MAAM,OAAO,aAAa,MAAM;CAChC,MAAM,QAAQ,aAAa,MAAM;CACjC,MAAM,aAAa,SAAS;CAE5B,MAAM,SAAS,OAAO,IAAI,gBAAgB;CAC1C,MAAM,SAAuB,EAAE;CAC/B,MAAM,QAA0B,EAAE;AAElC,MAAK,MAAM,MAAM,OACf,KAAI,SAAS,IAAI,GAAG,EAAE,CACpB,QAAO,KAAK,GAAG;KAEf,OAAM,KAAK;EACT,SAAS;EACT,MAAM,GAAG;EACT,OAAO,GAAG;EACV,SAAS,CAAC,GAAG;EACd,CAAC;AAIN,KAAI,OAAO,SAAS,GAAG;EACrB,MAAM,YAAY,KAAK,IAAI,GAAG,OAAO,KAAK,OAAO,GAAG,MAAM,CAAC;EAI3D,MAAM,UAAU,aACZ,wBAAwB,OAAO,GAC/B,wBAAwB,OAAO;AAEnC,QAAM,KAAK;GACT,SAAS;GACT,MAAM;GACN,OAAO,KAAK,IACV,GAAG,OAAO,QAAQ,OAAO,GAAG,UAAU,UAAU,CAAC,KAAK,OAAO,GAAG,OAAO,CACxE;GACD;GACA,QAAQ,QAAQ,KAAK,QAAQ;IAAE,GAAG,GAAG;IAAG,GAAG,GAAG;IAAG,EAAE;GACpD,CAAC;;AAGJ,OAAM,MAAM,GAAG,MAAM;AACnB,MAAI,EAAE,SAAS,EAAE,KAAM,QAAO,EAAE,OAAO,EAAE;AAGzC,MAAI,EAAE,YAAY,EAAE,QAAS,QAAO,EAAE,YAAY,aAAa,KAAK;AACpE,MAAI,EAAE,UAAU,EAAE,MAAO,QAAO,EAAE,QAAQ,EAAE;AAE5C,SAAO;GACP;CAOF,MAAM,QAAQ,MAAM,SAAS,SAAS,KAAK,QAAQ;CACnD,MAAM,cAAc,WAAW,OAAO;CACtC,IAAI,OAAO,OAAO,YAAY;AAE9B,MAAK,MAAM,QAAQ,OAAO;AAcxB,MAAI,EAZF,KAAK,WACL,KAAK,QAAQ,SAAS,KACtB,KAAK,WAAW,UAChB,WAAW,aAAa,KAAK,SAAS,KAAK,QAAQ;GACjD;GACA;GACA,SAAS,aAAa,WAAW;GAClC,CAAC,GAKU;AACZ,QAAK,MAAM,KAAK,KAAK,SAAS;AAC5B,QAAI,CAAC,EAAE,QAAQ;AACb,SAAI,WACF,uBAAsB,aAAa,GAAG,MAAM,MAAM;UAC7C;AACL,0BAAoB,aAAa,GAAG,OAAO,KAAK;AAChD,aAAO,KAAK,IAAI,MAAM,EAAE,IAAI,EAAE,EAAE;;AAElC,iBAAY,KAAK,EAAE;;AAErB,MAAE,QAAQ;;AAEZ;;AAGF,OAAK,MAAM,KAAK,KAAK,SAAS;AAC5B,eAAY,KAAK,EAAE;AACnB,OAAI,CAAC,WAAY,QAAO,KAAK,IAAI,MAAM,EAAE,IAAI,EAAE,EAAE;AACjD,KAAE,QAAQ;;;AAId,QAAO;;;;;;;;;;;;;;;;;AA+BT,SAAS,WACP,aACA,SACA,QACA,EAAE,YAAY,MAAM,WACX;CACT,MAAM,OAAO,aAAa,MAAM;CAChC,MAAM,OAAO,aAAa,MAAM;CAEhC,MAAM,gBAAgB;AACpB,UAAQ,SAAS,IAAI,UAAU;GAC7B,MAAM,KAAK,OAAO;AAClB,GAAC,GAA2B,IAAI,GAAG;AACnC,GAAC,GAA2B,IAAI,GAAG;IACnC;;AAGJ,UAAS;CAET,MAAM,SAAS,UAAkB;AAC/B,OAAK,MAAM,MAAM,QACf,CAAC,GAA2B,SAAS;;CAGzC,MAAM,oBAAoB,KAAK,IAAI,GAAG,QAAQ,KAAK,OAAO,GAAG,MAAM,CAAC;CACpE,MAAM,qBACJ,KAAK,IAAI,GAAG,QAAQ,KAAK,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;CACvD,MAAM,iBACJ,QAAQ,MAAM,OAAO,kBAAkB,aAAa,GAAG,KAAK,OAAU;AAGxE,KAAI,aAAa,GAAG,EAAG,OAAM,CAAC,aAAa,CAAC;CAC5C,MAAM,YAAY,aAAa,GAAG;AAClC,KAAI,YAAY,EAAG,OAAM,CAAC,UAAU;AAOpC,QAAO,aAAa,GAAG,GAAG;AACxB,QAAM,GAAG;AACT,MAAI,UAAU,EAAE;AACd,SAAM,EAAE;AACR;;;AAIJ,KAAI,CAAC,UAAU,EAAE;AAIf,MAAI,CAAC,cAAc,cAAc,IAAI,KAAM,QAAO;AAClD,WAAS;AAET,SAAO;;CAMT,MAAM,OAAO,QAAQ,QAAQ,OAAO,OAAO,QAAQ,GAAG,OAAO,EAAE;CAC/D,MAAM,QACJ,KAAK,IAAI,GAAG,GAAG,YAAY,KAAK,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC,GAC5D,OACA,QAAQ,SACR;AAEF,MAAK,IAAI,OAAO,GAAG,OAAO,OAAO,QAAQ;AACvC,QAAM,EAAE;AACR,MAAI,cAAc,cAAc,GAAG,MAAM;AACvC,YAAS;AACT,UAAO;;AAET,MAAI,CAAC,UAAU,CAAE,QAAO;;AAG1B,UAAS;AACT,QAAO;;;;;;;;;;;;;;;;;;;AAoBT,SAAS,eACP,QACA,QACA,MACS;CACT,MAAM,OAAO,SAAS,MAAM,MAAM;CAIlC,MAAM,UAAU,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,MACnC,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EACnC;CACD,MAAM,SAAuB,CAAC,GAAG,OAAO;CACxC,MAAM,SAAS,UACb,KAAK,IAAI,GAAG,GAAG,MAAM,KAAK,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;CACxD,MAAM,QAAQ,MAAM,OAAO,GAAG,MAAM,OAAO,GAAG,OAAO,SAAS;AAE9D,MAAK,MAAM,QAAQ,SAAS;AAC1B,MAAI,KAAK,QAAQ;AAGf,UAAO,KAAK,KAAK;AACjB;;EAGF,IAAI,QAAQ;EACZ,IAAI,UAAU;AAEd,SAAO,SAAS;AACd,aAAU;AACV,QAAK,MAAM,SAAS,OAClB,KAAI,SAAS,MAAM,MAAM,EAAE;AACzB,IAAC,KAA6B,QAAQ,MAAM,QAAQ,MAAM;AAC1D,cAAU;;AAGd,OAAI,EAAE,QAAQ,MACZ,QAAO;;AAIX,SAAO,KAAK,KAAK;;AAGnB,QAAO"}

package/dist/components/layout/Board/grid-core/layout.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { getAllCollisions, getFirstCollision } from "./collision.js";
 import { sortLayoutItems } from "./sort.js";
 

package/dist/components/layout/Board/grid-core/sort.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 //#region src/components/layout/Board/grid-core/sort.ts
 /**
 * Sort layout items based on the compaction type.

package/dist/components/layout/Board/index.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { getCompactor, horizontalCompactor, noCompactor, verticalCompactor } from "./grid-core/compactors.js";
 import { aspectRatio, boundedX, boundedY, containerBounds, gridBounds, maxSize, minMaxSize, minSize, snapToGrid } from "./grid-core/constraints.js";
 import { BoardProvider } from "./BoardProvider.js";

package/dist/components/layout/Board/responsive-utils.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { cloneLayout, correctBounds } from "./grid-core/layout.js";
 
 //#region src/components/layout/Board/responsive-utils.ts

package/dist/components/layout/Board/use-board-layout.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { cloneLayout } from "./grid-core/layout.js";
 import { useCallback, useEffect, useRef, useState } from "react";

package/dist/components/layout/Board/use-board-registry.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { BoardWidgetStore } from "./board-store.js";
 import { collides } from "./grid-core/collision.js";

package/dist/components/layout/Board/use-board-select-modifier-key.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useIsDarwin } from "../../../utils/react/useIsDarwin.js";
 
 //#region src/components/layout/Board/use-board-select-modifier-key.ts

package/dist/components/layout/Board/use-board-selection.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { useI18n } from "../../../i18n/useI18n.js";
 import { useEffect, useMemo, useRef, useState } from "react";

package/dist/components/layout/Flex.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { extractStyles } from "../../utils/styles.js";
 import { CONTAINER_STYLES, filterBaseProps, tasty } from "@tenphi/tasty";
 import { forwardRef } from "react";

package/dist/components/layout/Flow.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { extractStyles } from "../../utils/styles.js";
 import { CONTAINER_STYLES, filterBaseProps, tasty } from "@tenphi/tasty";
 import { forwardRef } from "react";

package/dist/components/layout/Grid.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { extractStyles } from "../../utils/styles.js";
 import { CONTAINER_STYLES, filterBaseProps, tasty } from "@tenphi/tasty";
 import { forwardRef } from "react";

package/dist/components/layout/Panel.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { BASE_STYLES, BLOCK_STYLES, COLOR_STYLES, DIMENSION_STYLES, OUTER_STYLES, tasty } from "@tenphi/tasty";
 import { forwardRef, useMemo } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";

package/dist/components/layout/Prefix.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { extractStyles } from "../../utils/styles.js";
 import { useLayoutEffect as useLayoutEffect$1 } from "../../utils/react/useLayoutEffect.js";
 import { useCombinedRefs } from "../../utils/react/useCombinedRefs.js";

package/dist/components/layout/ResizablePanel.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { mergeProps as mergeProps$1 } from "../../utils/react/mergeProps.js";
 import { useCombinedRefs } from "../../utils/react/useCombinedRefs.js";
 import { useEvent } from "../../_internal/hooks/use-event.js";

package/dist/components/layout/Space.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { extractStyles } from "../../utils/styles.js";
 import { CONTAINER_STYLES, filterBaseProps, tasty } from "@tenphi/tasty";
 import { forwardRef } from "react";

package/dist/components/layout/Suffix.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { extractStyles } from "../../utils/styles.js";
 import { useCombinedRefs } from "../../utils/react/useCombinedRefs.js";
 import { CONTAINER_STYLES, filterBaseProps, parseStyle, tasty } from "@tenphi/tasty";

package/dist/components/navigation/Pagination/Pagination.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { extractStyles } from "../../../utils/styles.js";
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { useI18n } from "../../../i18n/useI18n.js";

package/dist/components/navigation/Pagination/use-pagination.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { useMemo } from "react";
 import { useControlledState } from "@react-stately/utils";

package/dist/components/navigation/Tabs/DraggableTabList.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { DraggableCollection } from "../../shared/DraggableCollection.js";
 import { jsx } from "react/jsx-runtime";
 

package/dist/components/navigation/Tabs/TabButton.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { mergeProps as mergeProps$1 } from "../../../utils/react/mergeProps.js";
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { ItemActionProvider } from "../../actions/ItemActionContext.js";

package/dist/components/navigation/Tabs/TabDropIndicator.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { DropIndicatorElement } from "./styled.js";
 import { useTabsContext } from "./TabsContext.js";
 import { useEffect, useRef, useState } from "react";

package/dist/components/navigation/Tabs/TabPanel.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { TabPanelElement } from "./styled.js";
 import { useEffect, useMemo, useRef } from "react";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";

package/dist/components/navigation/Tabs/TabPicker.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { ItemAction } from "../../actions/ItemAction/ItemAction.js";
 import { useI18n } from "../../../i18n/useI18n.js";
 import { CloseIcon } from "../../../icons/CloseIcon.js";

package/dist/components/navigation/Tabs/Tabs.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { extractStyles } from "../../../utils/styles.js";
 import { mergeProps as mergeProps$1 } from "../../../utils/react/mergeProps.js";
 import { useEvent } from "../../../_internal/hooks/use-event.js";

package/dist/components/navigation/Tabs/TabsAction.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { _ItemButton } from "../../actions/ItemButton/ItemButton.js";
 import { useOptionalTabsContext } from "./TabsContext.js";
 import { tasty } from "@tenphi/tasty";

package/dist/components/navigation/Tabs/TabsContext.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { createContext, useContext } from "react";
 import { jsx } from "react/jsx-runtime";
 

package/dist/components/navigation/Tabs/popover-placement.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 //#region src/components/navigation/Tabs/popover-placement.ts
 /**
 * Maps the parent Tabs `placement` to the popover placement for menus and

package/dist/components/navigation/Tabs/styled.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { _Item } from "../../content/Item/Item.js";
 import { tasty } from "@tenphi/tasty";
 

package/dist/components/navigation/Tabs/types.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 //#region src/components/navigation/Tabs/types.ts
 /**
 * Size mapping for radio type tabs.

package/dist/components/navigation/Tabs/use-tab-editing.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useCallback, useState } from "react";
 
 //#region src/components/navigation/Tabs/use-tab-editing.ts

package/dist/components/navigation/Tabs/use-tab-indicator.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { chainRaf } from "../../../utils/raf.js";
 import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
 

package/dist/components/organisms/StatsCard/StatsCard.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { _Text } from "../../content/Text.js";
 import { _Title } from "../../content/Title.js";
 import { Card } from "../../content/Card/Card.js";

package/dist/components/other/Calendar/Calendar.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { _Title } from "../../content/Title.js";
 import { useProviderProps } from "../../../provider.js";
 import { Space } from "../../layout/Space.js";

package/dist/components/other/Calendar/CalendarCell.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { tasty } from "@tenphi/tasty";
 import { useRef } from "react";
 import { jsx } from "react/jsx-runtime";

package/dist/components/other/Calendar/CalendarGrid.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { getWeekNumber } from "../../fields/DatePicker/period.js";
 import { CalendarCell } from "./CalendarCell.js";
 import { tasty } from "@tenphi/tasty";

package/dist/components/other/Calendar/PeriodCalendar.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { _Title } from "../../content/Title.js";
 import { useProviderProps } from "../../../provider.js";
 import { Space } from "../../layout/Space.js";

package/dist/components/other/Calendar/RangeCalendar.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { _Title } from "../../content/Title.js";
 import { useProviderProps } from "../../../provider.js";
 import { Space } from "../../layout/Space.js";

package/dist/components/other/CubeLogo/CubeLogo.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { Icon } from "../../../icons/Icon.js";
 import { mergeStyles, tasty } from "@tenphi/tasty";
 import { forwardRef } from "react";

package/dist/components/overlays/AlertDialog/AlertDialog.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { chain } from "../../../utils/react/chain.js";
 import { Paragraph } from "../../content/Paragraph.js";
 import { _Title } from "../../content/Title.js";

package/dist/components/overlays/AlertDialog/AlertDialogApiProvider.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { AlertDialogZone } from "./AlertDialogZone.js";
 import { createContext, useContext, useMemo, useRef, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";

package/dist/components/overlays/AlertDialog/AlertDialogZone.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { Portal } from "../../portal/Portal.js";
 import { DialogContainer } from "../Dialog/DialogContainer.js";
 import { _AlertDialog } from "./AlertDialog.js";

package/dist/components/overlays/Dialog/Dialog.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { extractStyles } from "../../../utils/styles.js";
 import { mergeProps as mergeProps$1 } from "../../../utils/react/mergeProps.js";
 import { SlotProvider } from "../../../utils/react/Slots.js";

package/dist/components/overlays/Dialog/DialogContainer.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { _Modal } from "../Modal/Modal.js";
 import { DialogContext } from "./context.js";
 import { Children, isValidElement, useRef } from "react";

package/dist/components/overlays/Dialog/DialogForm.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { _Title } from "../../content/Title.js";
 import { useI18n } from "../../../i18n/useI18n.js";
 import { ButtonGroup } from "../../actions/ButtonGroup/ButtonGroup.js";

package/dist/components/overlays/Dialog/DialogTrigger.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useLayoutEffect as useLayoutEffect$1 } from "../../../utils/react/useLayoutEffect.js";
 import { useCombinedRefs } from "../../../utils/react/useCombinedRefs.js";
 import { usePopoverSync } from "../../../utils/react/usePopoverSync.js";

package/dist/components/overlays/Dialog/context.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { createContext, useContext } from "react";
 import invariant from "tiny-invariant";
 

package/dist/components/overlays/Dialog/use-dialog-container.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { mergeProps } from "../../../utils/react/mergeProps.js";
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { DialogContainer } from "./DialogContainer.js";

package/dist/components/overlays/Modal/Modal.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { mergeProps as mergeProps$1 } from "../../../utils/react/mergeProps.js";
 import { _Overlay } from "./Overlay.js";
 import { _Underlay } from "./Underlay.js";

package/dist/components/overlays/Modal/OpenTransitionContext.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { createContext, useContext } from "react";
 
 //#region src/components/overlays/Modal/OpenTransitionContext.tsx

package/dist/components/overlays/Modal/Overlay.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { DisplayTransition } from "../../helpers/DisplayTransition/DisplayTransition.js";
 import { Provider, useProviderProps } from "../../../provider.js";
 import { OpenTransitionContext } from "./OpenTransitionContext.js";

package/dist/components/overlays/Modal/Popover.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { mergeProps as mergeProps$1 } from "../../../utils/react/mergeProps.js";
 import { _Overlay } from "./Overlay.js";
 import { tasty } from "@tenphi/tasty";

package/dist/components/overlays/Modal/Tray.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { mergeProps as mergeProps$1 } from "../../../utils/react/mergeProps.js";
 import { _Overlay } from "./Overlay.js";
 import { _Underlay } from "./Underlay.js";

package/dist/components/overlays/Modal/Underlay.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { tasty } from "@tenphi/tasty";
 import { forwardRef } from "react";
 import { jsx } from "react/jsx-runtime";

package/dist/components/overlays/Notifications/Notification.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useNotificationContext } from "./NotificationContext.js";
 import { useEffect, useRef } from "react";
 

package/dist/components/overlays/Notifications/NotificationAction.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { ItemAction } from "../../actions/ItemAction/ItemAction.js";
 import { createContext, useContext, useMemo } from "react";

package/dist/components/overlays/Notifications/NotificationCard.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { Block } from "../../Block.js";
 import { ItemActionProvider } from "../../actions/ItemActionContext.js";
 import { Space } from "../../layout/Space.js";

package/dist/components/overlays/Notifications/NotificationContext.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { createContext, useContext } from "react";
 
 //#region src/components/overlays/Notifications/NotificationContext.ts

package/dist/components/overlays/Notifications/NotificationItem.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { NotificationCard } from "./NotificationCard.js";
 import { tasty } from "@tenphi/tasty";

package/dist/components/overlays/Notifications/OverlayContainer.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useLayoutEffect as useLayoutEffect$1 } from "../../../utils/react/useLayoutEffect.js";
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { DisplayTransition } from "../../helpers/DisplayTransition/DisplayTransition.js";

package/dist/components/overlays/Notifications/OverlayProvider.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { NotificationContext, PersistentNotificationsContext, ToastContext, useNotificationContext, useToastContext } from "./NotificationContext.js";
 import { OverlayContainer } from "./OverlayContainer.js";
 import { useNotificationState } from "./use-notification-state.js";

package/dist/components/overlays/Notifications/PersistentNotificationsList.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { _Text } from "../../content/Text.js";
 import { useI18n } from "../../../i18n/useI18n.js";

package/dist/components/overlays/Notifications/dismissed-storage.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 //#region src/components/overlays/Notifications/dismissed-storage.ts
 const STORAGE_KEY = "cube-ui-dismissed-notifications";
 const TTL_MS = 864e5;

package/dist/components/overlays/Notifications/format-relative-time.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 //#region src/components/overlays/Notifications/format-relative-time.ts
 /**
 * Lightweight relative time formatter.

package/dist/components/overlays/Notifications/index.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useToastContext } from "./NotificationContext.js";
 import { NotificationAction } from "./NotificationAction.js";
 import { NotificationCard } from "./NotificationCard.js";

package/dist/components/overlays/Notifications/use-notification-state.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.158.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.160.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { useRef, useState } from "react";