@smwb/ui-solid 0.12.1 → 0.14.0

package/dist/source/components/layout/tabGroups/tabGroupsLayout.js

@@ -0,0 +1,629 @@
+const TAB_GROUPS_LAYOUT_VERSION = 1;
+const NEW_GROUP_PLACES = {
+  top: "above",
+  right: "on the right",
+  bottom: "below",
+  left: "on the left"
+};
+const TAB_GROUPS_LABELS = {
+  group: (index, count) => count === 1 ? "Tabs" : `Group ${index} of ${count}`,
+  groupActions: "Group actions",
+  splitRight: "Split right",
+  splitDown: "Split down",
+  moveToPreviousGroup: "Move to previous group",
+  moveToNextGroup: "Move to next group",
+  moveLeft: "Move tab left",
+  moveRight: "Move tab right",
+  resize: "Resize groups",
+  movedToGroup: (tab, index, count) => `${tab} moved to group ${index} of ${count}`,
+  movedToNewGroup: (tab, edge) => `${tab} moved to a new group ${NEW_GROUP_PLACES[edge]}`,
+  movedInGroup: (tab, position, count) => `${tab} moved to position ${position} of ${count}`
+};
+const SNAP = 0.05;
+const SUM_TOLERANCE = 1e-6;
+const MIN_EXTENT = SNAP * 2;
+const MAX_DEPTH = 32;
+const ZONE_TOLERANCE = 1e-6;
+function itemAt(items, index) {
+  const item = items[index];
+  if (item === void 0) throw new RangeError(`tabGroupsLayout: no item at ${index}`);
+  return item;
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function round4(value) {
+  return Math.round(value * 1e4) / 1e4;
+}
+function sum(values) {
+  return values.reduce((total, value) => total + value, 0);
+}
+function collectGroups(node, out) {
+  if (node.type === "group") out.push(node);
+  else node.children.forEach((child) => collectGroups(child, out));
+  return out;
+}
+function firstGroup(node) {
+  return node.type === "group" ? node : firstGroup(itemAt(node.children, 0));
+}
+function lastGroup(node) {
+  return node.type === "group" ? node : lastGroup(itemAt(node.children, node.children.length - 1));
+}
+function forEachNode(node, visit) {
+  visit(node);
+  if (node.type === "split") node.children.forEach((child) => forEachNode(child, visit));
+}
+function findPath(node, id, path = []) {
+  if (node.id === id) return path;
+  if (node.type === "group") return void 0;
+  for (let index = 0; index < node.children.length; index++) {
+    const found = findPath(itemAt(node.children, index), id, [...path, index]);
+    if (found) return found;
+  }
+  return void 0;
+}
+function nodeAt(root, path) {
+  let node = root;
+  for (const index of path) node = itemAt(node.children, index);
+  return node;
+}
+function replaceAt(root, path, replacement) {
+  if (path.length === 0) return replacement;
+  const split = root;
+  const [index, ...rest] = path;
+  const children = split.children.slice();
+  children[index] = replaceAt(itemAt(children, index), rest, replacement);
+  return { ...split, children };
+}
+function getGroup(layout, groupId) {
+  return getGroups(layout).find((group) => group.id === groupId);
+}
+function replaceGroup(root, group) {
+  const path = findPath(root, group.id);
+  return path ? replaceAt(root, path, group) : root;
+}
+function withRoot(layout, root, activeGroup = layout.activeGroup) {
+  if (root === layout.root && activeGroup === layout.activeGroup) return layout;
+  return { version: TAB_GROUPS_LAYOUT_VERSION, root, activeGroup };
+}
+function resolveActiveGroup(before, root, wanted) {
+  const exists = (id) => id !== void 0 && collectGroups(root, []).some((group) => group.id === id);
+  if (exists(wanted)) return wanted;
+  const heir = adjacentGroup(before, wanted);
+  return heir !== void 0 && exists(heir) ? heir : firstGroup(root).id;
+}
+function nextId(root, prefix) {
+  let max = 0;
+  forEachNode(root, (node) => {
+    const match = /^(\D+)(\d+)$/.exec(node.id);
+    if (match && match[1] === prefix) max = Math.max(max, Number(match[2]));
+  });
+  return `${prefix}${max + 1}`;
+}
+function normalize(node) {
+  if (node.type === "group") return node;
+  let changed = false;
+  const children = [];
+  let sizes = [];
+  node.children.forEach((child, index) => {
+    const size = node.sizes[index] ?? 0;
+    const next = normalize(child);
+    if (next !== child) changed = true;
+    if (next.type === "split" && next.direction === node.direction) {
+      changed = true;
+      next.children.forEach((grandchild, inner) => {
+        children.push(grandchild);
+        sizes.push(size * (next.sizes[inner] ?? 0) / 100);
+      });
+    } else {
+      children.push(next);
+      sizes.push(size);
+    }
+  });
+  if (children.length === 1) return itemAt(children, 0);
+  const total = sum(sizes);
+  if (total > 0 && Math.abs(total - 100) > SUM_TOLERANCE) {
+    changed = true;
+    sizes = sizes.map((size) => size * 100 / total);
+  }
+  return changed ? { ...node, children, sizes } : node;
+}
+function removeAt(root, path) {
+  const parentPath = path.slice(0, -1);
+  const index = itemAt(path, path.length - 1);
+  const parent = nodeAt(root, parentPath);
+  const heir = index > 0 ? index - 1 : index + 1;
+  const sizes = parent.sizes.slice();
+  sizes[heir] = (sizes[heir] ?? 0) + (sizes[index] ?? 0);
+  sizes.splice(index, 1);
+  const children = parent.children.filter((_, i) => i !== index);
+  return normalize(replaceAt(root, parentPath, { ...parent, children, sizes }));
+}
+function detachTab(root, group, tabId) {
+  const path = findPath(root, group.id);
+  const index = group.tabs.indexOf(tabId);
+  const tabs = group.tabs.filter((tab) => tab !== tabId);
+  if (tabs.length === 0 && path.length > 0) return { root: removeAt(root, path), closed: true };
+  const active = group.active === tabId ? tabs[index] ?? tabs[index - 1] ?? null : group.active;
+  return { root: replaceAt(root, path, { ...group, tabs, active }), closed: false };
+}
+function insertTab(root, groupId, tabId, index, select) {
+  const path = findPath(root, groupId);
+  const group = nodeAt(root, path);
+  const tabs = group.tabs.slice();
+  tabs.splice(clamp(index ?? tabs.length, 0, tabs.length), 0, tabId);
+  const active = select || group.active === null ? tabId : group.active;
+  return replaceAt(root, path, { ...group, tabs, active });
+}
+function insertBeside(root, targetId, node, edge, splitId) {
+  const path = findPath(root, targetId);
+  const direction = edge === "left" || edge === "right" ? "row" : "column";
+  const before = edge === "left" || edge === "top";
+  if (path.length > 0) {
+    const parentPath = path.slice(0, -1);
+    const index = itemAt(path, path.length - 1);
+    const parent = nodeAt(root, parentPath);
+    if (parent.direction === direction) {
+      const half = (parent.sizes[index] ?? 0) / 2;
+      const children = parent.children.slice();
+      const sizes = parent.sizes.slice();
+      sizes[index] = half;
+      const at = before ? index : index + 1;
+      children.splice(at, 0, node);
+      sizes.splice(at, 0, half);
+      return replaceAt(root, parentPath, { ...parent, children, sizes });
+    }
+  }
+  const target = nodeAt(root, path);
+  const split = {
+    type: "split",
+    id: splitId,
+    direction,
+    children: before ? [node, target] : [target, node],
+    sizes: [50, 50]
+  };
+  return replaceAt(root, path, split);
+}
+function createTabGroupsLayout(tabs = [], options = {}) {
+  const unique = Array.from(new Set(tabs));
+  const active = options.active !== void 0 && unique.includes(options.active) ? options.active : unique[0] ?? null;
+  return {
+    version: TAB_GROUPS_LAYOUT_VERSION,
+    root: { type: "group", id: "g1", tabs: unique, active },
+    activeGroup: "g1"
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readNode(raw, seen, depth = 0) {
+  if (!isRecord(raw) || depth > MAX_DEPTH) return null;
+  const id = typeof raw.id === "string" ? raw.id : "";
+  if (raw.type === "group") {
+    const tabs = [];
+    if (Array.isArray(raw.tabs)) {
+      for (const tab of raw.tabs) {
+        if (typeof tab !== "string" || seen.has(tab)) continue;
+        seen.add(tab);
+        tabs.push(tab);
+      }
+    }
+    const active = typeof raw.active === "string" && tabs.includes(raw.active) ? raw.active : tabs[0] ?? null;
+    return { type: "group", id, tabs, active };
+  }
+  const direction = raw.direction;
+  if (raw.type !== "split" || direction !== "row" && direction !== "column" || !Array.isArray(raw.children)) {
+    return null;
+  }
+  const rawChildren = raw.children;
+  const rawSizes = raw.sizes;
+  const validSizes = Array.isArray(rawSizes) && rawSizes.length === rawChildren.length && rawSizes.every((size) => typeof size === "number" && Number.isFinite(size) && size > 0);
+  const scale = validSizes && !Number.isFinite(sum(rawSizes) * 100) ? Math.max(...rawSizes) : 1;
+  const children = [];
+  const sizes = [];
+  rawChildren.forEach((rawChild, index) => {
+    const child = readNode(rawChild, seen, depth + 1);
+    if (!child) return;
+    children.push(child);
+    sizes.push(validSizes ? (rawSizes[index] ?? scale) / scale : 1);
+  });
+  if (children.length === 0) return null;
+  return { type: "split", id, direction, children, sizes };
+}
+function pruneEmpty(node) {
+  if (node.type === "group") return node.tabs.length > 0 ? node : null;
+  const children = [];
+  const sizes = [];
+  node.children.forEach((child, index) => {
+    const next = pruneEmpty(child);
+    if (!next) return;
+    children.push(next);
+    sizes.push(node.sizes[index] ?? 0);
+  });
+  return children.length > 0 ? { ...node, children, sizes } : null;
+}
+function keepDrawable(node, width = 100, height = 100) {
+  if (node.type === "group") return node;
+  const row = node.direction === "row";
+  const extent = row ? width : height;
+  const floor = extent > 0 ? MIN_EXTENT / extent * 100 : 100;
+  let sizes = node.sizes;
+  if (floor * sizes.length >= 100) {
+    if (sizes.some((size) => Math.abs(size - 100 / node.sizes.length) > SUM_TOLERANCE)) {
+      sizes = sizes.map(() => 100 / node.sizes.length);
+    }
+  } else if (sizes.some((size) => size < floor)) {
+    const short = sum(sizes.map((size) => Math.max(0, floor - size)));
+    const spare = sum(sizes.map((size) => Math.max(0, size - floor)));
+    sizes = sizes.map((size) => size < floor ? floor : size - (size - floor) * short / spare);
+  }
+  let changed = sizes !== node.sizes;
+  const children = node.children.map((child, index) => {
+    const share = (sizes[index] ?? 0) / 100;
+    const next = keepDrawable(child, row ? width * share : width, row ? height : height * share);
+    if (next !== child) changed = true;
+    return next;
+  });
+  return changed ? { ...node, children, sizes } : node;
+}
+function assignIds(root) {
+  const used = /* @__PURE__ */ new Set();
+  const missing = /* @__PURE__ */ new Set();
+  forEachNode(root, (node) => {
+    if (node.id !== "" && !used.has(node.id)) used.add(node.id);
+    else missing.add(node);
+  });
+  if (missing.size === 0) return root;
+  const counters = { g: 0, s: 0 };
+  used.forEach((id) => {
+    const match = /^(\D+)(\d+)$/.exec(id);
+    if (match && (match[1] === "g" || match[1] === "s")) {
+      counters[match[1]] = Math.max(counters[match[1]], Number(match[2]));
+    }
+  });
+  const rebuild = (node) => {
+    const prefix = node.type === "group" ? "g" : "s";
+    const id = missing.has(node) ? `${prefix}${++counters[prefix]}` : node.id;
+    return node.type === "group" ? { ...node, id } : { ...node, id, children: node.children.map(rebuild) };
+  };
+  return rebuild(root);
+}
+function parseTabGroupsLayout(raw, options = {}) {
+  if (!isRecord(raw) || raw.version !== TAB_GROUPS_LAYOUT_VERSION) return null;
+  const parsed = readNode(raw.root, /* @__PURE__ */ new Set());
+  if (!parsed) return null;
+  const pruned = pruneEmpty(parsed);
+  const root = assignIds(
+    pruned ? keepDrawable(normalize(pruned)) : { type: "group", id: firstGroup(parsed).id, tabs: [], active: null }
+  );
+  const groups = collectGroups(root, []);
+  const activeGroup = groups.some((group) => group.id === raw.activeGroup) ? raw.activeGroup : itemAt(groups, 0).id;
+  const layout = { version: TAB_GROUPS_LAYOUT_VERSION, root, activeGroup };
+  return options.tabs ? syncTabs(layout, options.tabs) : layout;
+}
+function syncTabs(layout, tabs) {
+  const wanted = new Set(tabs);
+  let next = layout;
+  getGroups(layout).forEach(
+    (group) => group.tabs.forEach((tab) => {
+      if (!wanted.has(tab)) next = removeTab(next, tab);
+    })
+  );
+  tabs.forEach((tab) => {
+    if (!findGroupOfTab(next, tab)) next = addTab(next, tab, { select: false });
+  });
+  return next;
+}
+function getGroups(layout) {
+  return collectGroups(layout.root, []);
+}
+function findGroupOfTab(layout, tabId) {
+  return getGroups(layout).find((group) => group.tabs.includes(tabId));
+}
+function addTab(layout, tabId, options = {}) {
+  const target = getGroup(layout, options.group ?? layout.activeGroup);
+  if (!target) return layout;
+  const select = options.select ?? true;
+  const source = findGroupOfTab(layout, tabId);
+  if (source && source.id === target.id) {
+    const moved = reorderTab(layout, source, tabId, options.index);
+    return select ? selectTab(moved, tabId) : moved;
+  }
+  let root = layout.root;
+  let closed = false;
+  if (source) ({ root, closed } = detachTab(root, source, tabId));
+  root = insertTab(root, target.id, tabId, options.index, select);
+  const activeGroup = select ? target.id : closed ? resolveActiveGroup(layout, root, layout.activeGroup) : layout.activeGroup;
+  return withRoot(layout, root, activeGroup);
+}
+function removeTab(layout, tabId) {
+  const group = findGroupOfTab(layout, tabId);
+  if (!group) return layout;
+  const { root } = detachTab(layout.root, group, tabId);
+  return withRoot(layout, root, resolveActiveGroup(layout, root, layout.activeGroup));
+}
+function selectTab(layout, tabId) {
+  const group = findGroupOfTab(layout, tabId);
+  if (!group) return layout;
+  const root = group.active === tabId ? layout.root : replaceGroup(layout.root, { ...group, active: tabId });
+  return withRoot(layout, root, group.id);
+}
+function setActiveGroup(layout, groupId) {
+  return getGroup(layout, groupId) ? withRoot(layout, layout.root, groupId) : layout;
+}
+function reorderTab(layout, group, tabId, index) {
+  const from = group.tabs.indexOf(tabId);
+  const last = group.tabs.length - 1;
+  const to = clamp(index ?? last, 0, last);
+  if (to === from) return layout;
+  const tabs = group.tabs.slice();
+  tabs.splice(from, 1);
+  tabs.splice(to, 0, tabId);
+  return withRoot(layout, replaceGroup(layout.root, { ...group, tabs }));
+}
+function moveTab(layout, tabId, target) {
+  const source = findGroupOfTab(layout, tabId);
+  const destination = getGroup(layout, target.group);
+  if (!source || !destination) return layout;
+  if (target.edge === void 0) {
+    if (destination.id === source.id) return reorderTab(layout, source, tabId, target.index);
+    return addTab(layout, tabId, {
+      group: destination.id,
+      ...target.index === void 0 ? {} : { index: target.index }
+    });
+  }
+  if (destination.id === source.id && source.tabs.length < 2) return layout;
+  const groupId = nextId(layout.root, "g");
+  const splitId = nextId(layout.root, "s");
+  const { root } = detachTab(layout.root, source, tabId);
+  const group = { type: "group", id: groupId, tabs: [tabId], active: tabId };
+  return withRoot(layout, insertBeside(root, destination.id, group, target.edge, splitId), groupId);
+}
+function moveTabInDirection(layout, tabId, edge) {
+  const group = findGroupOfTab(layout, tabId);
+  if (!group) return layout;
+  const neighbour = neighbourGroup(layout, group.id, edge);
+  if (neighbour !== void 0) return moveTab(layout, tabId, { group: neighbour });
+  return moveTab(layout, tabId, { group: group.id, edge });
+}
+function extentAlong(root, path, direction) {
+  let extent = 100;
+  let node = root;
+  for (const index of path) {
+    if (node.type !== "split") break;
+    if (node.direction === direction) extent *= (node.sizes[index] ?? 0) / (sum(node.sizes) || 1);
+    node = itemAt(node.children, index);
+  }
+  return extent;
+}
+function leastShare(node, direction, min) {
+  if (node.type === "group") return min;
+  const parts = node.children.map((child) => leastShare(child, direction, min));
+  if (node.direction !== direction) return Math.max(...parts);
+  const total = sum(node.sizes) || 1;
+  return Math.max(
+    ...parts.map((part, index) => {
+      const fraction = (node.sizes[index] ?? 0) / total;
+      return fraction > 0 ? part / fraction : Number.POSITIVE_INFINITY;
+    })
+  );
+}
+function resizeSplit(layout, splitId, index, delta, min = 0) {
+  const path = findPath(layout.root, splitId);
+  if (!path) return layout;
+  const split = nodeAt(layout.root, path);
+  if (split.type !== "split" || !Number.isInteger(index) || index < 0 || index >= split.children.length - 1) {
+    return layout;
+  }
+  if (Number.isNaN(delta) || delta === 0) return layout;
+  const first = split.sizes[index] ?? 0;
+  const second = split.sizes[index + 1] ?? 0;
+  const pair = first + second;
+  const extent = extentAlong(layout.root, path, split.direction);
+  const floor = extent > 0 ? MIN_EXTENT / extent * 100 : 0;
+  const least = (child) => Math.min(pair, Math.max(floor, leastShare(child, split.direction, min > 0 ? min : 0)));
+  let lowFirst = least(itemAt(split.children, index));
+  let lowSecond = least(itemAt(split.children, index + 1));
+  if (lowFirst + lowSecond > pair) {
+    const scale = pair / (lowFirst + lowSecond);
+    lowFirst *= scale;
+    lowSecond *= scale;
+  }
+  const next = clamp(first + delta, lowFirst, pair - lowSecond);
+  if (next === first) return layout;
+  const sizes = split.sizes.slice();
+  sizes[index] = next;
+  sizes[index + 1] = pair - next;
+  return withRoot(layout, replaceAt(layout.root, path, { ...split, sizes }));
+}
+function walkRects(node, rect, onGroup, onSeparator) {
+  if (node.type === "group") {
+    onGroup(node, rect);
+    return;
+  }
+  const total = sum(node.sizes) || 1;
+  const row = node.direction === "row";
+  const start = row ? rect.x0 : rect.y0;
+  const extent = row ? rect.x1 - rect.x0 : rect.y1 - rect.y0;
+  let offset = 0;
+  node.children.forEach((child, index) => {
+    const from = start + extent * offset / total;
+    offset += node.sizes[index] ?? 0;
+    const to = index === node.children.length - 1 ? row ? rect.x1 : rect.y1 : start + extent * offset / total;
+    const childRect = row ? { ...rect, x0: from, x1: to } : { ...rect, y0: from, y1: to };
+    walkRects(child, childRect, onGroup, onSeparator);
+    if (onSeparator && index < node.children.length - 1) onSeparator(node, index, to, rect);
+  });
+}
+const ROOT_RECT = { x0: 0, y0: 0, x1: 100, y1: 100 };
+function groupRects(layout) {
+  const out = [];
+  walkRects(layout.root, ROOT_RECT, (group, rect) => out.push({ group, rect }));
+  return out;
+}
+function neighbourGroup(layout, groupId, edge) {
+  const rects = groupRects(layout);
+  const own = rects.find((entry) => entry.group.id === groupId)?.rect;
+  if (!own) return void 0;
+  const horizontal = edge === "left" || edge === "right";
+  let best;
+  let bestOverlap = SNAP;
+  rects.forEach(({ group, rect }) => {
+    if (group.id === groupId) return;
+    const touches = edge === "right" ? Math.abs(rect.x0 - own.x1) < SNAP : edge === "left" ? Math.abs(rect.x1 - own.x0) < SNAP : edge === "bottom" ? Math.abs(rect.y0 - own.y1) < SNAP : Math.abs(rect.y1 - own.y0) < SNAP;
+    if (!touches) return;
+    const overlap = horizontal ? Math.min(rect.y1, own.y1) - Math.max(rect.y0, own.y0) : Math.min(rect.x1, own.x1) - Math.max(rect.x0, own.x0);
+    if (overlap > bestOverlap + SUM_TOLERANCE) {
+      best = group.id;
+      bestOverlap = overlap;
+    }
+  });
+  return best;
+}
+function adjacentGroup(layout, groupId) {
+  const path = findPath(layout.root, groupId);
+  if (!path || path.length === 0 || nodeAt(layout.root, path).type !== "group") return void 0;
+  const parent = nodeAt(layout.root, path.slice(0, -1));
+  const index = itemAt(path, path.length - 1);
+  const previous = parent.children[index - 1];
+  if (previous) return lastGroup(previous).id;
+  const next = parent.children[index + 1];
+  return next ? firstGroup(next).id : void 0;
+}
+function dropZoneAt(x, y, width, height, edgeSize = 0.25) {
+  if (!(width > 0) || !(height > 0)) return "center";
+  const px = clamp(x, 0, width) / width;
+  const py = clamp(y, 0, height) / height;
+  const distances = [
+    ["top", py],
+    ["right", 1 - px],
+    ["bottom", 1 - py],
+    ["left", px]
+  ];
+  let zone = "center";
+  let nearest = Infinity;
+  distances.forEach(([edge, distance]) => {
+    if (distance < edgeSize && distance < nearest - ZONE_TOLERANCE) {
+      zone = edge;
+      nearest = distance;
+    }
+  });
+  return zone;
+}
+function snapLines(values) {
+  const lines = [];
+  values.slice().sort((a, b) => a - b).forEach((value) => {
+    const last = lines[lines.length - 1];
+    if (last === void 0 || value - last >= SNAP) lines.push(value);
+  });
+  return lines;
+}
+function lineIndex(lines, value) {
+  let found = 0;
+  lines.forEach((line, index) => {
+    if (line <= value + 1e-9) found = index;
+  });
+  return found;
+}
+function spans(lines, from, to) {
+  const start = lineIndex(lines, from);
+  return [start, Math.max(start + 1, lineIndex(lines, to))];
+}
+function tracks(lines) {
+  return lines.slice(1).map((line, index) => round4(line - itemAt(lines, index)));
+}
+function computeTabGroupsGrid(layout) {
+  const placed = [];
+  const cuts = [];
+  walkRects(
+    layout.root,
+    ROOT_RECT,
+    (group, rect) => placed.push({ group, rect }),
+    (split, index, position, rect) => cuts.push({ split, index, position, rect })
+  );
+  const xs = snapLines(placed.flatMap(({ rect }) => [rect.x0, rect.x1]));
+  const ys = snapLines(placed.flatMap(({ rect }) => [rect.y0, rect.y1]));
+  const columns = tracks(xs);
+  const rows = tracks(ys);
+  return {
+    columns,
+    rows,
+    groups: placed.map(({ group, rect }) => ({
+      id: group.id,
+      column: spans(xs, rect.x0, rect.x1),
+      row: spans(ys, rect.y0, rect.y1)
+    })),
+    separators: cuts.map(({ split, index, position, rect }) => {
+      const vertical = split.direction === "row";
+      const count = vertical ? columns.length : rows.length;
+      return {
+        split: split.id,
+        index,
+        orientation: vertical ? "vertical" : "horizontal",
+        line: clamp(lineIndex(vertical ? xs : ys, position), 1, Math.max(1, count - 1)),
+        span: vertical ? spans(ys, rect.y0, rect.y1) : spans(xs, rect.x0, rect.x1)
+      };
+    })
+  };
+}
+const SEPARATOR_TRACK = " var(--smwb-tab-groups-separator-size) ";
+function gridTemplateColumns(grid) {
+  return grid.columns.map((width) => `minmax(0, ${width}fr)`).join(SEPARATOR_TRACK);
+}
+function gridTemplateRows(grid) {
+  return grid.rows.map((height) => `auto minmax(0, ${height}fr)`).join(SEPARATOR_TRACK);
+}
+function groupHeaderArea(group) {
+  const [a, b] = group.column;
+  const [c] = group.row;
+  return `${3 * c + 1} / ${2 * a + 1} / ${3 * c + 2} / ${2 * b}`;
+}
+function groupBodyArea(group) {
+  const [a, b] = group.column;
+  const [c, d] = group.row;
+  return `${3 * c + 2} / ${2 * a + 1} / ${3 * d} / ${2 * b}`;
+}
+function separatorArea(separator) {
+  const k = separator.line;
+  const [from, to] = separator.span;
+  return separator.orientation === "vertical" ? `${3 * from + 1} / ${2 * k} / ${3 * to} / ${2 * k + 1}` : `${3 * k} / ${2 * from + 1} / ${3 * k + 1} / ${2 * to}`;
+}
+function describeTabGroupsChange(change, layout, title, labels = TAB_GROUPS_LABELS) {
+  if (change.type === "split") return labels.movedToNewGroup(title(change.tab), change.edge);
+  if (change.type !== "move") return "";
+  if (change.from === change.to) {
+    const group = getGroup(layout, change.to);
+    const position = group ? group.tabs.indexOf(change.tab) + 1 : 0;
+    return labels.movedInGroup(title(change.tab), position || change.index + 1, group?.tabs.length ?? 0);
+  }
+  const groups = getGroups(layout);
+  const index = groups.findIndex((group) => group.id === change.to);
+  return labels.movedToGroup(title(change.tab), index + 1, groups.length);
+}
+export {
+  TAB_GROUPS_LABELS,
+  TAB_GROUPS_LAYOUT_VERSION,
+  addTab,
+  adjacentGroup,
+  computeTabGroupsGrid,
+  createTabGroupsLayout,
+  describeTabGroupsChange,
+  dropZoneAt,
+  findGroupOfTab,
+  getGroups,
+  gridTemplateColumns,
+  gridTemplateRows,
+  groupBodyArea,
+  groupHeaderArea,
+  moveTab,
+  moveTabInDirection,
+  neighbourGroup,
+  parseTabGroupsLayout,
+  removeTab,
+  resizeSplit,
+  selectTab,
+  separatorArea,
+  setActiveGroup,
+  syncTabs
+};
+//# sourceMappingURL=tabGroupsLayout.js.map