[Init] Initial commit - NetMesh terminal manager

domain/toolbarItemLayout.ts

@@ -0,0 +1,290 @@
+/**
+ * Shared layout model for dense toolbar regions.
+ *
+ * Placement:
+ * - show: render inline on the toolbar
+ * - collapse: render inside the ⋮ overflow menu
+ * - hide: do not render
+ */
+
+export type ToolbarItemPlacement = 'show' | 'collapse' | 'hide';
+
+export const TOOLBAR_ITEM_PLACEMENTS: readonly ToolbarItemPlacement[] = [
+  'show',
+  'collapse',
+  'hide',
+] as const;
+
+export type ToolbarItemLayout = {
+  order: string[];
+  placement: Record<string, ToolbarItemPlacement>;
+};
+
+export type ToolbarItemLayoutDefaults = {
+  /** Canonical item ids in default visual order. */
+  order: readonly string[];
+  /** Default placement per id. Missing ids default to "show". */
+  placement?: Readonly<Partial<Record<string, ToolbarItemPlacement>>>;
+  /**
+   * Ids that cannot be hidden (or further restricted). They always stay
+   * available; default placement is "show" unless defaults.placement says
+   * otherwise for collapse-only locks.
+   */
+  lockedIds?: readonly string[];
+  /**
+   * When true (default), at least one available item must remain
+   * show or collapse so the region never becomes empty.
+   */
+  requireReachable?: boolean;
+};
+
+export type ToolbarItemPartition = {
+  shown: string[];
+  collapsed: string[];
+  hidden: string[];
+};
+
+export function isToolbarItemPlacement(value: unknown): value is ToolbarItemPlacement {
+  return value === 'show' || value === 'collapse' || value === 'hide';
+}
+
+function defaultPlacementFor(
+  id: string,
+  defaults: ToolbarItemLayoutDefaults,
+): ToolbarItemPlacement {
+  const locked = defaults.lockedIds?.includes(id) ?? false;
+  const configured = defaults.placement?.[id];
+  if (configured && isToolbarItemPlacement(configured)) {
+    if (locked && configured === 'hide') return 'show';
+    return configured;
+  }
+  return 'show';
+}
+
+function buildDefaultLayout(defaults: ToolbarItemLayoutDefaults): ToolbarItemLayout {
+  const order = [...defaults.order];
+  const placement: Record<string, ToolbarItemPlacement> = {};
+  for (const id of order) {
+    placement[id] = defaultPlacementFor(id, defaults);
+  }
+  return { order, placement };
+}
+
+/**
+ * Accepts:
+ * - full { order, placement } objects
+ * - legacy order-only arrays (all items default placement)
+ * - null / garbage → defaults
+ */
+export function normalizeToolbarItemLayout(
+  value: unknown,
+  defaults: ToolbarItemLayoutDefaults,
+): ToolbarItemLayout {
+  const fallback = buildDefaultLayout(defaults);
+  const known = new Set(defaults.order);
+  if (known.size === 0) return fallback;
+
+  let rawOrder: unknown[] | null = null;
+  let rawPlacement: Record<string, unknown> | null = null;
+
+  if (Array.isArray(value)) {
+    rawOrder = value;
+  } else if (value && typeof value === 'object') {
+    const obj = value as Record<string, unknown>;
+    if (Array.isArray(obj.order)) rawOrder = obj.order;
+    if (obj.placement && typeof obj.placement === 'object' && !Array.isArray(obj.placement)) {
+      rawPlacement = obj.placement as Record<string, unknown>;
+    }
+  }
+
+  if (!rawOrder) return fallback;
+
+  const seen = new Set<string>();
+  const order: string[] = [];
+  for (const candidate of rawOrder) {
+    if (typeof candidate !== 'string') continue;
+    if (!known.has(candidate) || seen.has(candidate)) continue;
+    seen.add(candidate);
+    order.push(candidate);
+  }
+  for (const id of defaults.order) {
+    if (!seen.has(id)) order.push(id);
+  }
+
+  const placement: Record<string, ToolbarItemPlacement> = {};
+  for (const id of order) {
+    const fromRaw = rawPlacement?.[id];
+    if (isToolbarItemPlacement(fromRaw)) {
+      placement[id] = fromRaw;
+    } else {
+      placement[id] = defaultPlacementFor(id, defaults);
+    }
+    if ((defaults.lockedIds?.includes(id) ?? false) && placement[id] === 'hide') {
+      placement[id] = defaultPlacementFor(id, defaults) === 'collapse' ? 'collapse' : 'show';
+    }
+  }
+
+  return ensureReachable({ order, placement }, defaults, known);
+}
+
+function toIdSet(ids?: readonly string[] | ReadonlySet<string> | null): Set<string> | null {
+  if (ids == null) return null;
+  return ids instanceof Set ? ids : new Set(ids);
+}
+
+function ensureReachable(
+  layout: ToolbarItemLayout,
+  defaults: ToolbarItemLayoutDefaults,
+  known: Set<string>,
+  /**
+   * When provided, reachability is computed only over currently available ids
+   * (e.g. session-specific toolbar actions). Unavailable "show" entries must
+   * not keep an empty visible toolbar looking "reachable".
+   */
+  availableIds?: readonly string[] | ReadonlySet<string> | null,
+): ToolbarItemLayout {
+  if (defaults.requireReachable === false) return layout;
+
+  const available = toIdSet(availableIds);
+
+  const isCandidate = (id: string): boolean => {
+    if (!known.has(id)) return false;
+    if (available && !available.has(id)) return false;
+    return true;
+  };
+
+  const hasReachable = layout.order.some((id) => {
+    if (!isCandidate(id)) return false;
+    const p = layout.placement[id] ?? 'show';
+    return p === 'show' || p === 'collapse';
+  });
+  if (hasReachable) return layout;
+
+  // Prefer restoring the first always-present (available) non-locked default.
+  const restoreId =
+    defaults.order.find(
+      (id) => isCandidate(id) && !(defaults.lockedIds?.includes(id) ?? false),
+    ) ??
+    defaults.order.find((id) => isCandidate(id)) ??
+    defaults.order[0];
+  if (!restoreId) return layout;
+  return {
+    order: layout.order,
+    placement: {
+      ...layout.placement,
+      [restoreId]: 'show',
+    },
+  };
+}
+
+/** Split layout into shown / collapsed / hidden, optionally filtering by currently available ids. */
+export function partitionToolbarItems(
+  layout: ToolbarItemLayout,
+  availableIds?: readonly string[] | ReadonlySet<string>,
+): ToolbarItemPartition {
+  const available =
+    availableIds == null
+      ? null
+      : availableIds instanceof Set
+        ? availableIds
+        : new Set(availableIds);
+
+  const shown: string[] = [];
+  const collapsed: string[] = [];
+  const hidden: string[] = [];
+
+  for (const id of layout.order) {
+    if (available && !available.has(id)) continue;
+    const placement = layout.placement[id] ?? 'show';
+    if (placement === 'show') shown.push(id);
+    else if (placement === 'collapse') collapsed.push(id);
+    else hidden.push(id);
+  }
+
+  return { shown, collapsed, hidden };
+}
+
+export function setToolbarItemPlacement(
+  layout: ToolbarItemLayout,
+  id: string,
+  placement: ToolbarItemPlacement,
+  defaults: ToolbarItemLayoutDefaults,
+  availableIds?: readonly string[] | ReadonlySet<string> | null,
+): ToolbarItemLayout {
+  if (!layout.order.includes(id) && !defaults.order.includes(id)) return layout;
+  if ((defaults.lockedIds?.includes(id) ?? false) && placement === 'hide') {
+    return layout;
+  }
+
+  const next: ToolbarItemLayout = {
+    order: layout.order.includes(id) ? layout.order : [...layout.order, id],
+    placement: {
+      ...layout.placement,
+      [id]: placement,
+    },
+  };
+  return ensureReachable(next, defaults, new Set(defaults.order), availableIds);
+}
+
+/**
+ * Reorder `draggedId` relative to `targetId`.
+ * Operates on the full order array (shown + collapsed + hidden).
+ */
+export function reorderToolbarItems(
+  layout: ToolbarItemLayout,
+  draggedId: string,
+  targetId: string,
+  placement: 'before' | 'after' = 'before',
+): ToolbarItemLayout {
+  if (draggedId === targetId) return layout;
+  const order = layout.order;
+  if (!order.includes(draggedId) || !order.includes(targetId)) return layout;
+
+  const withoutDragged = order.filter((id) => id !== draggedId);
+  const targetIndex = withoutDragged.indexOf(targetId);
+  if (targetIndex === -1) return layout;
+  const insertionIndex = placement === 'after' ? targetIndex + 1 : targetIndex;
+
+  return {
+    ...layout,
+    order: [
+      ...withoutDragged.slice(0, insertionIndex),
+      draggedId,
+      ...withoutDragged.slice(insertionIndex),
+    ],
+  };
+}
+
+/**
+ * Move an item one step earlier/later in order.
+ * When `availableIds` is set, skip unavailable neighbors so the UI reorder
+ * matches the filtered customize list.
+ */
+export function moveToolbarItem(
+  layout: ToolbarItemLayout,
+  id: string,
+  direction: 'earlier' | 'later',
+  availableIds?: readonly string[] | ReadonlySet<string> | null,
+): ToolbarItemLayout {
+  const available = toIdSet(availableIds);
+  const sequence = available
+    ? layout.order.filter((candidate) => available.has(candidate))
+    : layout.order;
+  const index = sequence.indexOf(id);
+  if (index === -1) return layout;
+  const swapWith = direction === 'earlier' ? index - 1 : index + 1;
+  if (swapWith < 0 || swapWith >= sequence.length) return layout;
+
+  const a = sequence[index];
+  const b = sequence[swapWith];
+  const order = layout.order.map((candidate) => {
+    if (candidate === a) return b;
+    if (candidate === b) return a;
+    return candidate;
+  });
+  return { ...layout, order };
+}
+
+export function resetToolbarItemLayout(defaults: ToolbarItemLayoutDefaults): ToolbarItemLayout {
+  return buildDefaultLayout(defaults);
+}