@nvidia-elements/core 2.22.4 → 2.23.0

package/dist/workspace/utils/interaction/boundary.utils.d.ts

@@ -0,0 +1,40 @@
+import type { Point, Rect } from '@nvidia-elements/core/internal';
+import { getCurrentInsertionSeam } from './insertion-offers.utils.js';
+import type { WorkspaceDropIntent } from './drag-preview.utils.js';
+import type { WorkspaceInsertionOffer } from './insertion-offers.utils.js';
+type Side = 'left' | 'right' | 'top' | 'bottom';
+interface BoundaryInput {
+    offers: WorkspaceInsertionOffer[];
+    bounds: Rect;
+    point: Point;
+    current?: WorkspaceDropIntent;
+    headers: Rect[];
+    geometry?: Parameters<typeof getCurrentInsertionSeam>[1];
+}
+/** Separates a mathematical boundary selection from its clipped, inward-only cue. */
+export declare function getBoundaryPlacementOffers(input: BoundaryInput): {
+    offers: {
+        kind: 'order' | 'insert';
+        owner: string;
+        boundary?: 'start' | 'end';
+        scope: NonNullable<ReturnType<typeof import("../placement/group-insertion.utils.js").describePlacementSlot>>;
+        plan: import("../placement/planner.utils.js").WorkspacePlacementPlan;
+        hitRect?: Rect;
+        scopeRect: Rect;
+        destination: import("../model/operations.utils.js").WorkspaceDestination;
+        rect: Rect;
+    }[];
+    hit: {
+        kind: 'order' | 'insert';
+        owner: string;
+        boundary?: 'start' | 'end';
+        scope: NonNullable<ReturnType<typeof import("../placement/group-insertion.utils.js").describePlacementSlot>>;
+        plan: import("../placement/planner.utils.js").WorkspacePlacementPlan;
+        hitRect?: Rect;
+        scopeRect: Rect;
+        destination: import("../model/operations.utils.js").WorkspaceDestination;
+        rect: Rect;
+    } | undefined;
+};
+export declare function getBoundarySide(bounds: Rect, point: Point, current?: Side): Side;
+export {};

package/dist/workspace/utils/interaction/boundary.utils.js

@@ -0,0 +1,91 @@
+import { getCurrentInsertionSeam as e, partitionPlacementOffers as t, placementOwnsChrome as n } from "./insertion-offers.utils.js";
+// src/workspace/utils/interaction/boundary.utils.ts
+var r = [
+	"left",
+	"right",
+	"top",
+	"bottom"
+];
+function i(e) {
+	let { offers: n, bounds: r, point: i, current: l } = e, u = n.filter((e) => e.owner === "root" && e.boundary), d = s(r, i, l && l.kind !== "invalid" && l.kind !== "tab" ? l.destination.position : void 0), f = u.find((e) => e.destination.position === d), p = f && c(r, i)[d] <= 6 ? f : void 0, m = t(n.filter((e) => !u.includes(e))).flatMap((t) => o({
+		input: e,
+		roots: u,
+		offer: t
+	})), h = u.filter((e) => e.destination.position === d).flatMap((e) => {
+		let t = a(r, d);
+		return t.width && t.height ? [{
+			...e,
+			rect: t
+		}] : [];
+	});
+	return {
+		offers: [...h, ...m],
+		hit: p ? h.find((e) => e.scope.key === p.scope.key) : void 0
+	};
+}
+function a(e, t) {
+	return t === "left" || t === "right" ? {
+		x: t === "left" ? e.x : e.x + e.width - 6,
+		y: e.y,
+		width: 6,
+		height: e.height
+	} : {
+		x: e.x,
+		y: t === "top" ? e.y : e.y + e.height - 6,
+		width: e.width,
+		height: 6
+	};
+}
+function o({ input: t, roots: r, offer: i }) {
+	let a = t.offers.find((e) => e.scope.key === i.scope.key), o = t.geometry ? e(a, t.geometry) ?? a.rect : a.rect, s = i.destination.position, c = s === "left" || s === "right", d = { ...i.rect };
+	return r.some((e) => e.destination.position === s) && l(d, t.bounds, s) && (c ? d.x += s === "left" ? 6 : -6 : d.y += s === "top" ? 6 : -6), n(i) ? [{
+		...i,
+		rect: a.rect,
+		hitRect: d
+	}] : u(d, t.headers, c).map((e) => ({
+		...i,
+		rect: o,
+		hitRect: e
+	}));
+}
+function s(e, t, n) {
+	let i = c(e, t), a = Math.min(...Object.values(i)), o = r.filter((e) => i[e] === a);
+	return n && o.includes(n) ? n : o[0];
+}
+function c(e, t) {
+	return {
+		left: t.x - e.x,
+		right: e.x + e.width - t.x,
+		top: t.y - e.y,
+		bottom: e.y + e.height - t.y
+	};
+}
+function l(e, t, n) {
+	switch (n) {
+		case "left": return Math.abs(e.x - t.x) < 1;
+		case "right": return Math.abs(e.x + e.width - t.x - t.width) < 1;
+		case "top": return Math.abs(e.y - t.y) < 1;
+		case "bottom":
+		case "tab": return Math.abs(e.y + e.height - t.y - t.height) < 1;
+	}
+}
+function u(e, t, n = e.width === 12) {
+	let r = [e];
+	for (let e of t) r = r.flatMap((t) => d(t, e, n));
+	return r;
+}
+function d(e, t, n) {
+	if (e.x >= t.x + t.width || e.x + e.width <= t.x || e.y >= t.y + t.height || e.y + e.height <= t.y) return [e];
+	let r = n ? "y" : "x", i = n ? "height" : "width", a = t[r] - e[r], o = e[r] + e[i] - t[r] - t[i], s = [];
+	return a > 0 && s.push({
+		...e,
+		[i]: a
+	}), o > 0 && s.push({
+		...e,
+		[r]: t[r] + t[i],
+		[i]: o
+	}), s;
+}
+export { i as getBoundaryPlacementOffers, s as getBoundarySide };
+
+//# sourceMappingURL=boundary.utils.js.map

package/dist/workspace/utils/interaction/boundary.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary.utils.js","names":["sides","getBoundaryPlacementOffers","input","roots","offers","offer","side","getBoundarySide","bounds","point","current","root","hit","edgeDistances","local","partitionPlacementOffers","localGeometry","painted","rect","boundaryPaint","paint","original","paintRect","getCurrentInsertionSeam","position","vertical","touches","placementOwnsChrome","protectChrome","distances","minimum","tied","fragments","header","headers","subtractHeaderFromFragment","fragment","start","extent","before","after"],"sources":["../../../../src/workspace/utils/interaction/boundary.utils.ts"],"sourcesContent":["// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Point, Rect } from '@nvidia-elements/core/internal';\n\nimport { getCurrentInsertionSeam, partitionPlacementOffers, placementOwnsChrome } from './insertion-offers.utils.js';\n\nimport type { WorkspaceDropIntent } from './drag-preview.utils.js';\nimport type { WorkspaceInsertionOffer } from './insertion-offers.utils.js';\n\ntype Side = 'left' | 'right' | 'top' | 'bottom';\n\nconst sides: Side[] = ['left', 'right', 'top', 'bottom'];\n\ninterface BoundaryInput {\n  offers: WorkspaceInsertionOffer[];\n  bounds: Rect;\n  point: Point;\n  current?: WorkspaceDropIntent;\n  headers: Rect[];\n  geometry?: Parameters<typeof getCurrentInsertionSeam>[1];\n}\n\n/** Separates a mathematical boundary selection from its clipped, inward-only cue. */\nexport function getBoundaryPlacementOffers(input: BoundaryInput) {\n  const { offers, bounds, point, current } = input;\n  const roots = offers.filter(offer => offer.owner === 'root' && offer.boundary);\n  const side = getBoundarySide(\n    bounds,\n    point,\n    current && current.kind !== 'invalid' && current.kind !== 'tab' ? current.destination.position : undefined\n  );\n  const root = roots.find(offer => offer.destination.position === side);\n  const hit = root && edgeDistances(bounds, point)[side] <= 6 ? root : undefined;\n  const local = partitionPlacementOffers(offers.filter(offer => !roots.includes(offer))).flatMap(offer =>\n    localGeometry({ input, roots, offer })\n  );\n  const painted = roots\n    .filter(offer => offer.destination.position === side)\n    .flatMap(offer => {\n      const rect = boundaryPaint(bounds, side);\n      return rect.width && rect.height ? [{ ...offer, rect }] : [];\n    });\n  return {\n    offers: [...painted, ...local],\n    hit: hit ? painted.find(offer => offer.scope.key === hit.scope.key) : undefined\n  };\n}\n\nfunction boundaryPaint(bounds: Rect, side: Side): Rect {\n  if (side === 'left' || side === 'right') {\n    const x = side === 'left' ? bounds.x : bounds.x + bounds.width - 6;\n    return { x, y: bounds.y, width: 6, height: bounds.height };\n  }\n\n  const x = bounds.x;\n  const y = side === 'top' ? bounds.y : bounds.y + bounds.height - 6;\n  return { x, y, width: bounds.width, height: 6 };\n}\n\nfunction localGeometry({\n  input,\n  roots,\n  offer\n}: {\n  input: BoundaryInput;\n  roots: WorkspaceInsertionOffer[];\n  offer: WorkspaceInsertionOffer;\n}) {\n  const paint = input.offers.find(original => original.scope.key === offer.scope.key)!;\n  const paintRect = input.geometry ? (getCurrentInsertionSeam(paint, input.geometry) ?? paint.rect) : paint.rect;\n  const position = offer.destination.position;\n  const vertical = position === 'left' || position === 'right';\n  const rect = { ...offer.rect };\n  if (roots.some(root => root.destination.position === position) && touches(rect, input.bounds, position)) {\n    if (vertical) {\n      rect.x += position === 'left' ? 6 : -6;\n    } else {\n      rect.y += position === 'top' ? 6 : -6;\n    }\n  }\n  if (placementOwnsChrome(offer)) return [{ ...offer, rect: paint.rect, hitRect: rect }];\n  return protectChrome(rect, input.headers, vertical).map(hitRect => ({\n    ...offer,\n    rect: paintRect,\n    hitRect\n  }));\n}\n\nexport function getBoundarySide(bounds: Rect, point: Point, current?: Side): Side {\n  const distances = edgeDistances(bounds, point);\n  const minimum = Math.min(...Object.values(distances));\n  const tied = sides.filter(side => distances[side] === minimum);\n  return current && tied.includes(current) ? current : tied[0]!;\n}\n\nfunction edgeDistances(bounds: Rect, point: Point) {\n  return {\n    left: point.x - bounds.x,\n    right: bounds.x + bounds.width - point.x,\n    top: point.y - bounds.y,\n    bottom: bounds.y + bounds.height - point.y\n  };\n}\n\nfunction touches(rect: Rect, bounds: Rect, side: WorkspaceInsertionOffer['destination']['position']) {\n  switch (side) {\n    case 'left':\n      return Math.abs(rect.x - bounds.x) < 1;\n    case 'right':\n      return Math.abs(rect.x + rect.width - bounds.x - bounds.width) < 1;\n    case 'top':\n      return Math.abs(rect.y - bounds.y) < 1;\n    case 'bottom':\n    case 'tab':\n      return Math.abs(rect.y + rect.height - bounds.y - bounds.height) < 1;\n  }\n}\n\nfunction protectChrome(rect: Rect, headers: Rect[], vertical = rect.width === 12): Rect[] {\n  let fragments = [rect];\n  for (const header of headers) {\n    fragments = fragments.flatMap(fragment => subtractHeaderFromFragment(fragment, header, vertical));\n  }\n  return fragments;\n}\n\nfunction subtractHeaderFromFragment(fragment: Rect, header: Rect, vertical: boolean): Rect[] {\n  if (\n    fragment.x >= header.x + header.width ||\n    fragment.x + fragment.width <= header.x ||\n    fragment.y >= header.y + header.height ||\n    fragment.y + fragment.height <= header.y\n  ) {\n    return [fragment];\n  }\n  const start = vertical ? 'y' : 'x';\n  const extent = vertical ? 'height' : 'width';\n  const before = header[start] - fragment[start];\n  const after = fragment[start] + fragment[extent] - header[start] - header[extent];\n  const fragments: Rect[] = [];\n  if (before > 0) {\n    fragments.push({ ...fragment, [extent]: before });\n  }\n  if (after > 0) {\n    fragments.push({ ...fragment, [start]: header[start] + header[extent], [extent]: after });\n  }\n  return fragments;\n}\n"],"mappings":"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"}

package/dist/workspace/utils/interaction/command.utils.d.ts

@@ -0,0 +1,74 @@
+import type { WorkspaceDropIntent } from './drag-preview.utils.js';
+import type { WorkspaceLayout } from '../model/layout.utils.js';
+import type { WorkspacePanel } from '../../panel/panel.js';
+export type WorkspaceSide = 'left' | 'right' | 'top' | 'bottom';
+/** A placement supplied on the invoker's `placement` property for `--place`.
+ * Source defaults to one panel; `group` carries its entire current group, including closed members.
+ * An arrangement target identifies the enclosing split of the target panel, before source removal.
+ */
+export type WorkspacePlacement = {
+    source?: 'panel' | 'group';
+} & ({
+    operation: 'split';
+    target: string;
+    position: WorkspaceSide;
+} | {
+    operation: 'join';
+    target: string;
+    index?: number;
+} | {
+    operation: 'reorder';
+    target: string;
+    position: 'before' | 'after';
+} | {
+    operation: 'insert';
+    scope: 'arrangement';
+    target: string;
+    position: WorkspaceSide;
+} | {
+    operation: 'insert';
+    scope: 'workspace';
+    position: WorkspaceSide;
+});
+export type WorkspacePlacementIntent = Exclude<WorkspaceDropIntent, {
+    kind: 'invalid';
+}>;
+/** Identifies a supplied panel and optional placement without requiring an invoker element. */
+export interface WorkspaceCommandContext {
+    value?: string | null;
+    placement?: WorkspacePlacement;
+}
+export interface WorkspaceCommandSource extends HTMLElement, WorkspaceCommandContext {
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+export type WorkspaceCommandEvent = Event & {
+    command?: string;
+    source?: WorkspaceCommandSource | null;
+};
+interface WorkspaceCommandAvailability {
+    command: string;
+    context: WorkspaceCommandContext;
+    layout?: WorkspaceLayout;
+    available: string[];
+    closable: boolean;
+    rearrangeable: boolean;
+    placementAvailable(source: string[], intent: WorkspacePlacementIntent): boolean;
+    canEnterFullscreen(anchor: string): boolean;
+    canExitFullscreen(): boolean;
+    isFullscreenGroup(anchor: string): boolean;
+}
+export declare function findWorkspaceCommandPanel(host: HTMLElement, panels: WorkspacePanel[], event: WorkspaceCommandEvent): WorkspacePanel | undefined;
+export declare function isWorkspaceCommandAvailable(input: WorkspaceCommandAvailability): boolean;
+export declare function isWorkspacePlacement(value: unknown): value is WorkspacePlacement;
+/** Resolves panel IDs to placement operations without exposing region paths. */
+export declare function resolveWorkspacePlacement(input: {
+    layout: WorkspaceLayout;
+    available: string[];
+    anchor: string;
+    placement: WorkspacePlacement;
+}): {
+    source: string[];
+    intent: WorkspacePlacementIntent;
+} | undefined;
+export {};

package/dist/workspace/utils/interaction/command.utils.js

@@ -0,0 +1,189 @@
+import { getSplitSide as e } from "../model/layout.utils.js";
+import { findGroup as t, projectLayout as n } from "../model/operations.utils.js";
+// src/workspace/utils/interaction/command.utils.ts
+function r(e, t, n) {
+	return n.target === e ? t.find((e) => e.id === n.source?.value) : t.find((e) => e === n.target);
+}
+function i(e) {
+	let t = o(e);
+	if (!t) return !1;
+	let { id: n } = t;
+	switch (e.command) {
+		case "--enter-fullscreen": return e.canEnterFullscreen(n);
+		case "--exit-fullscreen": return e.canExitFullscreen();
+		case "--toggle-fullscreen": return e.isFullscreenGroup(n) ? e.canExitFullscreen() : e.canEnterFullscreen(n);
+		default: return a(e, t);
+	}
+}
+function a(e, t) {
+	let { id: n, group: r, closed: i } = t;
+	switch (e.command) {
+		case "--open": return i || r.active !== n;
+		case "--select": return !i && r.active !== n;
+		case "--close": return e.closable && !i;
+		case "--place": return s(e, n);
+		default: return !1;
+	}
+}
+function o(e) {
+	let n = e.context.value;
+	if (!n || !e.layout || !e.available.includes(n)) return;
+	let r = t(e.layout.root, n);
+	return r ? {
+		id: n,
+		group: r,
+		closed: e.layout.closed.includes(n)
+	} : void 0;
+}
+function s(e, t) {
+	let n = e.context.placement;
+	if (!e.rearrangeable || !c(n) || !e.layout) return !1;
+	let r = g({
+		layout: e.layout,
+		available: e.available,
+		anchor: t,
+		placement: n
+	});
+	return !!r && e.placementAvailable(r.source, r.intent);
+}
+function c(e) {
+	if (!p(e) || !l(e.source)) return !1;
+	switch (e.operation) {
+		case "split": return e.scope === void 0 && m(e.target) && h(e.position);
+		case "join": return u(e);
+		case "reorder": return d(e);
+		case "insert": return f(e);
+		default: return !1;
+	}
+}
+function l(e) {
+	return e === void 0 || e === "panel" || e === "group";
+}
+function u(e) {
+	let t = e.index;
+	return e.scope === void 0 && m(e.target) && (t === void 0 || typeof t == "number" && Number.isInteger(t) && t >= 0);
+}
+function d(e) {
+	return e.scope === void 0 && m(e.target) && (e.position === "before" || e.position === "after");
+}
+function f(e) {
+	return h(e.position) && (e.scope === "workspace" && e.target === void 0 || e.scope === "arrangement" && m(e.target));
+}
+function p(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+function m(e) {
+	return typeof e == "string" && e.length > 0;
+}
+function h(e) {
+	return e === "left" || e === "right" || e === "top" || e === "bottom";
+}
+function g(e) {
+	let { layout: r, available: i, anchor: a, placement: o } = e, s = i.filter((e) => !r.closed.includes(e));
+	if (!s.includes(a)) return;
+	let c = t(r.root, a);
+	if (!c) return;
+	let l = o.source === "group" ? [...c.panels] : [a], u = n(r, i).root;
+	if (o.operation === "insert" && o.scope === "workspace") {
+		let e = b(u, l);
+		return e ? {
+			source: l,
+			intent: {
+				kind: "insert",
+				destination: {
+					target: e,
+					region: "root",
+					position: o.position
+				}
+			}
+		} : void 0;
+	}
+	if (!s.includes(o.target) || !t(u, o.target)) return;
+	let d = _({
+		root: u,
+		source: l,
+		placement: o
+	});
+	return d ? {
+		source: l,
+		intent: d
+	} : void 0;
+}
+function _({ root: e, source: t, placement: n }) {
+	let r = n.target;
+	switch (n.operation) {
+		case "join": return {
+			kind: "tab",
+			destination: {
+				target: r,
+				position: "tab",
+				index: n.index
+			}
+		};
+		case "split": return t.includes(r) ? void 0 : {
+			kind: "split",
+			destination: {
+				target: r,
+				position: n.position
+			}
+		};
+		case "reorder": return v({
+			root: e,
+			source: t,
+			target: r,
+			position: n.position
+		});
+		case "insert": {
+			let t = y(e, r)?.owner;
+			return t ? {
+				kind: "insert",
+				destination: {
+					target: r,
+					region: t.key,
+					position: n.position
+				}
+			} : void 0;
+		}
+	}
+}
+function v(n) {
+	let r = y(n.root, n.source[0]), i = r?.owner;
+	if (!i) return;
+	let a = i.node.children.findIndex((e) => !!t(e, n.target));
+	if (a < 0 || a === r.index) return;
+	let o = e(i.node.axis, n.position);
+	return {
+		kind: "order",
+		destination: {
+			target: n.target,
+			region: `${i.key}.${a}`,
+			position: o
+		}
+	};
+}
+function y(e, t, n = "root") {
+	if (e) {
+		if (e.type === "group") return e.panels.includes(t) ? {
+			group: e,
+			index: 0
+		} : void 0;
+		for (let [r, i] of e.children.entries()) {
+			if (i.type === "group" && i.panels.includes(t)) return {
+				group: i,
+				index: r,
+				owner: {
+					node: e,
+					key: n
+				}
+			};
+			let a = y(i, t, `${n}.${r}`);
+			if (a) return a;
+		}
+	}
+}
+function b(e, t) {
+	if (e) return e.type === "group" ? e.panels.find((e) => !t.includes(e)) : e.children.map((e) => b(e, t)).find(Boolean);
+}
+export { r as findWorkspaceCommandPanel, i as isWorkspaceCommandAvailable, c as isWorkspacePlacement, g as resolveWorkspacePlacement };
+
+//# sourceMappingURL=command.utils.js.map

package/dist/workspace/utils/interaction/command.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.utils.js","names":["findWorkspaceCommandPanel","event","host","panels","panel","isWorkspaceCommandAvailable","commandPanel","input","id","layoutCommandAvailable","closed","group","placementCommandAvailable","findGroup","placement","isWorkspacePlacement","request","resolveWorkspacePlacement","isRecord","value","isValidSource","isNonemptyString","isWorkspaceSide","hasValidJoinFields","hasValidReorderFields","hasValidInsertionFields","index","visible","available","layout","anchor","source","root","projectLayout","target","firstRemaining","intent","relativePlacement","peerOrder","owner","groupAddress","address","child","position","getSplitSide","node","nested","key"],"sources":["../../../../src/workspace/utils/interaction/command.utils.ts"],"sourcesContent":["// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { getSplitSide } from '../model/layout.utils.js';\nimport { findGroup, projectLayout } from '../model/operations.utils.js';\n\nimport type { WorkspaceDropIntent } from './drag-preview.utils.js';\nimport type { WorkspaceGroup, WorkspaceLayout, WorkspaceNode, WorkspaceSplit } from '../model/layout.utils.js';\n\nimport type { WorkspacePanel } from '../../panel/panel.js';\n\nexport type WorkspaceSide = 'left' | 'right' | 'top' | 'bottom';\n\n/** A placement supplied on the invoker's `placement` property for `--place`.\n * Source defaults to one panel; `group` carries its entire current group, including closed members.\n * An arrangement target identifies the enclosing split of the target panel, before source removal.\n */\nexport type WorkspacePlacement = { source?: 'panel' | 'group' } & (\n  | { operation: 'split'; target: string; position: WorkspaceSide }\n  | { operation: 'join'; target: string; index?: number }\n  | { operation: 'reorder'; target: string; position: 'before' | 'after' }\n  | { operation: 'insert'; scope: 'arrangement'; target: string; position: WorkspaceSide }\n  | { operation: 'insert'; scope: 'workspace'; position: WorkspaceSide }\n);\n\nexport type WorkspacePlacementIntent = Exclude<WorkspaceDropIntent, { kind: 'invalid' }>;\n\n/** Identifies a supplied panel and optional placement without requiring an invoker element. */\nexport interface WorkspaceCommandContext {\n  value?: string | null;\n  placement?: WorkspacePlacement;\n}\n\nexport interface WorkspaceCommandSource extends HTMLElement, WorkspaceCommandContext {\n  disabled?: boolean;\n  readOnly?: boolean;\n}\n\nexport type WorkspaceCommandEvent = Event & { command?: string; source?: WorkspaceCommandSource | null };\n\ninterface CommandPanelState {\n  id: string;\n  group: WorkspaceGroup;\n  closed: boolean;\n}\n\ninterface WorkspaceCommandAvailability {\n  command: string;\n  context: WorkspaceCommandContext;\n  layout?: WorkspaceLayout;\n  available: string[];\n  closable: boolean;\n  rearrangeable: boolean;\n  placementAvailable(source: string[], intent: WorkspacePlacementIntent): boolean;\n  canEnterFullscreen(anchor: string): boolean;\n  canExitFullscreen(): boolean;\n  isFullscreenGroup(anchor: string): boolean;\n}\n\nexport function findWorkspaceCommandPanel(\n  host: HTMLElement,\n  panels: WorkspacePanel[],\n  event: WorkspaceCommandEvent\n): WorkspacePanel | undefined {\n  return event.target === host\n    ? panels.find(panel => panel.id === event.source?.value)\n    : panels.find(panel => panel === event.target);\n}\n\nexport function isWorkspaceCommandAvailable(input: WorkspaceCommandAvailability): boolean {\n  const panel = commandPanel(input);\n  if (!panel) return false;\n  const { id } = panel;\n  switch (input.command) {\n    case '--enter-fullscreen':\n      return input.canEnterFullscreen(id);\n    case '--exit-fullscreen':\n      return input.canExitFullscreen();\n    case '--toggle-fullscreen':\n      if (input.isFullscreenGroup(id)) {\n        return input.canExitFullscreen();\n      }\n      return input.canEnterFullscreen(id);\n    default:\n      return layoutCommandAvailable(input, panel);\n  }\n}\n\nfunction layoutCommandAvailable(input: WorkspaceCommandAvailability, panel: CommandPanelState) {\n  const { id, group, closed } = panel;\n  switch (input.command) {\n    case '--open':\n      return closed || group.active !== id;\n    case '--select':\n      return !closed && group.active !== id;\n    case '--close':\n      return input.closable && !closed;\n    case '--place':\n      return placementCommandAvailable(input, id);\n    default:\n      return false;\n  }\n}\n\nfunction commandPanel(input: WorkspaceCommandAvailability): CommandPanelState | undefined {\n  const id = input.context.value;\n  if (!id || !input.layout || !input.available.includes(id)) return undefined;\n  const group = findGroup(input.layout.root, id);\n  return group ? { id, group, closed: input.layout.closed.includes(id) } : undefined;\n}\n\nfunction placementCommandAvailable(input: WorkspaceCommandAvailability, id: string) {\n  const placement = input.context.placement;\n  if (!input.rearrangeable || !isWorkspacePlacement(placement) || !input.layout) return false;\n  const request = resolveWorkspacePlacement({\n    layout: input.layout,\n    available: input.available,\n    anchor: id,\n    placement\n  });\n  return !!request && input.placementAvailable(request.source, request.intent);\n}\n\nexport function isWorkspacePlacement(value: unknown): value is WorkspacePlacement {\n  if (!isRecord(value) || !isValidSource(value.source)) return false;\n  switch (value.operation) {\n    case 'split':\n      return value.scope === undefined && isNonemptyString(value.target) && isWorkspaceSide(value.position);\n    case 'join':\n      return hasValidJoinFields(value);\n    case 'reorder':\n      return hasValidReorderFields(value);\n    case 'insert':\n      return hasValidInsertionFields(value);\n    default:\n      return false;\n  }\n}\n\nfunction isValidSource(value: unknown) {\n  return value === undefined || value === 'panel' || value === 'group';\n}\n\nfunction hasValidJoinFields(value: Record<string, unknown>) {\n  const index = value.index;\n  return (\n    value.scope === undefined &&\n    isNonemptyString(value.target) &&\n    (index === undefined || (typeof index === 'number' && Number.isInteger(index) && index >= 0))\n  );\n}\n\nfunction hasValidReorderFields(value: Record<string, unknown>) {\n  return (\n    value.scope === undefined &&\n    isNonemptyString(value.target) &&\n    (value.position === 'before' || value.position === 'after')\n  );\n}\n\nfunction hasValidInsertionFields(value: Record<string, unknown>) {\n  return (\n    isWorkspaceSide(value.position) &&\n    ((value.scope === 'workspace' && value.target === undefined) ||\n      (value.scope === 'arrangement' && isNonemptyString(value.target)))\n  );\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction isNonemptyString(value: unknown): value is string {\n  return typeof value === 'string' && value.length > 0;\n}\n\nfunction isWorkspaceSide(value: unknown): value is WorkspaceSide {\n  return value === 'left' || value === 'right' || value === 'top' || value === 'bottom';\n}\n\n/** Resolves panel IDs to placement operations without exposing region paths. */\nexport function resolveWorkspacePlacement(input: {\n  layout: WorkspaceLayout;\n  available: string[];\n  anchor: string;\n  placement: WorkspacePlacement;\n}): { source: string[]; intent: WorkspacePlacementIntent } | undefined {\n  const { layout, available, anchor, placement } = input;\n  const visible = available.filter(id => !layout.closed.includes(id));\n  if (!visible.includes(anchor)) return undefined;\n  const group = findGroup(layout.root, anchor);\n  if (!group) return undefined;\n  const source = placement.source === 'group' ? [...group.panels] : [anchor];\n  const root = projectLayout(layout, available).root;\n  if (placement.operation === 'insert' && placement.scope === 'workspace') {\n    const target = firstRemaining(root, source);\n    if (!target) return undefined;\n\n    return {\n      source,\n      intent: { kind: 'insert', destination: { target, region: 'root', position: placement.position } }\n    };\n  }\n  if (!visible.includes(placement.target) || !findGroup(root, placement.target)) return undefined;\n  const intent = relativePlacement({ root, source, placement });\n  return intent ? { source, intent } : undefined;\n}\n\nfunction relativePlacement({\n  root,\n  source,\n  placement\n}: {\n  root: WorkspaceNode | null;\n  source: string[];\n  placement: Exclude<WorkspacePlacement, { operation: 'insert'; scope: 'workspace' }>;\n}): WorkspacePlacementIntent | undefined {\n  const target = placement.target;\n  switch (placement.operation) {\n    case 'join':\n      return { kind: 'tab', destination: { target, position: 'tab', index: placement.index } };\n    case 'split':\n      if (source.includes(target)) return undefined;\n\n      return { kind: 'split', destination: { target, position: placement.position } };\n    case 'reorder':\n      return peerOrder({ root, source, target, position: placement.position });\n    case 'insert': {\n      const owner = groupAddress(root, target)?.owner;\n      if (!owner) return undefined;\n\n      return { kind: 'insert', destination: { target, region: owner.key, position: placement.position } };\n    }\n  }\n}\n\nfunction peerOrder(input: {\n  root: WorkspaceNode | null;\n  source: string[];\n  target: string;\n  position: 'before' | 'after';\n}): WorkspacePlacementIntent | undefined {\n  const address = groupAddress(input.root, input.source[0]!);\n  const owner = address?.owner;\n  if (!owner) return undefined;\n  const index = owner.node.children.findIndex(child => !!findGroup(child, input.target));\n  if (index < 0 || index === address.index) return undefined;\n  const position = getSplitSide(owner.node.axis, input.position);\n  return { kind: 'order', destination: { target: input.target, region: `${owner.key}.${index}`, position } };\n}\n\ninterface GroupAddress {\n  group: WorkspaceGroup;\n  index: number;\n  owner?: { node: WorkspaceSplit; key: string };\n}\n\nfunction groupAddress(node: WorkspaceNode | null, id: string, key = 'root'): GroupAddress | undefined {\n  if (!node) return undefined;\n  if (node.type === 'group') return node.panels.includes(id) ? { group: node, index: 0 } : undefined;\n  for (const [index, child] of node.children.entries()) {\n    if (child.type === 'group' && child.panels.includes(id)) return { group: child, index, owner: { node, key } };\n    const nested = groupAddress(child, id, `${key}.${index}`);\n    if (nested) return nested;\n  }\n  return undefined;\n}\n\nfunction firstRemaining(node: WorkspaceNode | null, source: string[]): string | undefined {\n  if (!node) return undefined;\n  return node.type === 'group'\n    ? node.panels.find(id => !source.includes(id))\n    : node.children.map(child => firstRemaining(child, source)).find(Boolean);\n}\n"],"mappings":"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"}

package/dist/workspace/utils/interaction/drag-preview.utils.d.ts

@@ -0,0 +1,79 @@
+import type { Point, Rect } from '@nvidia-elements/core/internal';
+import type { WorkspaceLayout } from '../model/layout.utils.js';
+import type { WorkspaceDestination } from '../model/operations.utils.js';
+import type { WorkspacePlacementContext } from '../placement/context.utils.js';
+import type { WorkspacePlacementPlan } from '../placement/planner.utils.js';
+import type { WorkspaceSeamPreview } from '../presentation/offers.utils.js';
+type TabDestination = Omit<WorkspaceDestination, 'position'> & {
+    position: 'tab';
+};
+type SplitDestination = Omit<WorkspaceDestination, 'position'> & {
+    position: Exclude<WorkspaceDestination['position'], 'tab'>;
+};
+export type WorkspaceDropIntent = {
+    kind: 'tab';
+    destination: TabDestination;
+} | {
+    kind: 'split' | 'order';
+    destination: SplitDestination;
+} | {
+    kind: 'insert';
+    destination: SplitDestination;
+} | {
+    kind: 'invalid';
+};
+export interface WorkspaceDragCue {
+    rect: Rect;
+    kind: 'tab' | 'group';
+}
+interface PreviewPresentation {
+    seams?: WorkspaceSeamPreview;
+    context?: WorkspacePlacementContext;
+    source: string[];
+    point?: Point;
+    cue: WorkspaceDragCue;
+}
+interface AttachedPreview extends PreviewPresentation {
+    phase: 'attached';
+    intent: {
+        kind: 'invalid';
+    };
+    blocked: false;
+}
+export type WorkspaceDragAllocation = {
+    allocation: 'overlay' | 'committed';
+} | {
+    allocation: 'reserved';
+    layout: WorkspaceLayout;
+};
+export type WorkspaceDragOffer = {
+    cue: WorkspaceDragCue;
+    feasible: boolean;
+    seams?: WorkspaceSeamPreview;
+    context?: WorkspacePlacementContext;
+} & WorkspaceDragAllocation;
+type DetachedPreview = PreviewPresentation & WorkspaceDragAllocation & {
+    phase: 'detached';
+    intent: WorkspaceDropIntent;
+    blocked: boolean;
+};
+export type WorkspaceDragPreview = AttachedPreview | DetachedPreview | (PreviewPresentation & WorkspaceDragAllocation & {
+    phase: 'returning-attached' | 'returning-detached';
+    intent: {
+        kind: 'invalid';
+    };
+    blocked: false;
+});
+export interface WorkspacePlacementAcquisition {
+    plan: WorkspacePlacementPlan;
+    rect: Rect;
+}
+export interface WorkspaceOfferContext {
+    selected?: WorkspaceDragPreview;
+    acquisition?: WorkspacePlacementAcquisition & {
+        point: Point;
+    };
+}
+export declare function clipCue(rect: Rect, bounds: Rect): Rect;
+export declare function matchesPlacementIntent(a: WorkspaceDropIntent, b: WorkspaceDropIntent): boolean;
+export {};

package/dist/workspace/utils/interaction/drag-preview.utils.js

@@ -0,0 +1,16 @@
+// src/workspace/utils/interaction/drag-preview.utils.ts
+function e(e, t) {
+	let n = Math.max(t.x, Math.min(e.x, t.x + t.width)), r = Math.max(t.y, Math.min(e.y, t.y + t.height));
+	return {
+		x: n,
+		y: r,
+		width: Math.max(0, Math.min(e.x + e.width, t.x + t.width) - n),
+		height: Math.max(0, Math.min(e.y + e.height, t.y + t.height) - r)
+	};
+}
+function t(e, t) {
+	return e.kind === "invalid" || t.kind === "invalid" || e.kind !== t.kind ? !1 : e.destination.target === t.destination.target && e.destination.region === t.destination.region && e.destination.position === t.destination.position && e.destination.index === t.destination.index;
+}
+export { e as clipCue, t as matchesPlacementIntent };
+
+//# sourceMappingURL=drag-preview.utils.js.map

package/dist/workspace/utils/interaction/drag-preview.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drag-preview.utils.js","names":["clipCue","x","bounds","rect","y","matchesPlacementIntent","a","b"],"sources":["../../../../src/workspace/utils/interaction/drag-preview.utils.ts"],"sourcesContent":["// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Point, Rect } from '@nvidia-elements/core/internal';\n\nimport type { WorkspaceLayout } from '../model/layout.utils.js';\nimport type { WorkspaceDestination } from '../model/operations.utils.js';\nimport type { WorkspacePlacementContext } from '../placement/context.utils.js';\nimport type { WorkspacePlacementPlan } from '../placement/planner.utils.js';\nimport type { WorkspaceSeamPreview } from '../presentation/offers.utils.js';\n\ntype TabDestination = Omit<WorkspaceDestination, 'position'> & { position: 'tab' };\n\ntype SplitDestination = Omit<WorkspaceDestination, 'position'> & {\n  position: Exclude<WorkspaceDestination['position'], 'tab'>;\n};\n\nexport type WorkspaceDropIntent =\n  | { kind: 'tab'; destination: TabDestination }\n  | { kind: 'split' | 'order'; destination: SplitDestination }\n  | { kind: 'insert'; destination: SplitDestination }\n  | { kind: 'invalid' };\n\nexport interface WorkspaceDragCue {\n  rect: Rect;\n  kind: 'tab' | 'group';\n}\n\ninterface PreviewPresentation {\n  seams?: WorkspaceSeamPreview;\n  context?: WorkspacePlacementContext;\n  source: string[];\n  point?: Point;\n  cue: WorkspaceDragCue;\n}\n\ninterface AttachedPreview extends PreviewPresentation {\n  phase: 'attached';\n  intent: { kind: 'invalid' };\n  blocked: false;\n}\n\nexport type WorkspaceDragAllocation =\n  | { allocation: 'overlay' | 'committed' }\n  | { allocation: 'reserved'; layout: WorkspaceLayout };\n\nexport type WorkspaceDragOffer = {\n  cue: WorkspaceDragCue;\n  feasible: boolean;\n  seams?: WorkspaceSeamPreview;\n  context?: WorkspacePlacementContext;\n} & WorkspaceDragAllocation;\n\ntype DetachedPreview = PreviewPresentation &\n  WorkspaceDragAllocation & {\n    phase: 'detached';\n    intent: WorkspaceDropIntent;\n    blocked: boolean;\n  };\n\nexport type WorkspaceDragPreview =\n  | AttachedPreview\n  | DetachedPreview\n  | (PreviewPresentation &\n      WorkspaceDragAllocation & {\n        phase: 'returning-attached' | 'returning-detached';\n        intent: { kind: 'invalid' };\n        blocked: false;\n      });\n\nexport interface WorkspacePlacementAcquisition {\n  plan: WorkspacePlacementPlan;\n  rect: Rect;\n}\n\nexport interface WorkspaceOfferContext {\n  selected?: WorkspaceDragPreview;\n  acquisition?: WorkspacePlacementAcquisition & { point: Point };\n}\n\nexport function clipCue(rect: Rect, bounds: Rect): Rect {\n  const x = Math.max(bounds.x, Math.min(rect.x, bounds.x + bounds.width));\n  const y = Math.max(bounds.y, Math.min(rect.y, bounds.y + bounds.height));\n  return {\n    x,\n    y,\n    width: Math.max(0, Math.min(rect.x + rect.width, bounds.x + bounds.width) - x),\n    height: Math.max(0, Math.min(rect.y + rect.height, bounds.y + bounds.height) - y)\n  };\n}\n\nexport function matchesPlacementIntent(a: WorkspaceDropIntent, b: WorkspaceDropIntent) {\n  if (a.kind === 'invalid' || b.kind === 'invalid' || a.kind !== b.kind) return false;\n  return (\n    a.destination.target === b.destination.target &&\n    a.destination.region === b.destination.region &&\n    a.destination.position === b.destination.position &&\n    a.destination.index === b.destination.index\n  );\n}\n"],"mappings":";AAgFA,SAAgBA,EAAQ,GAAY,GAAoB;CACtD,IAAMC,IAAI,KAAK,IAAIC,EAAO,GAAG,KAAK,IAAIC,EAAK,GAAGD,EAAO,IAAIA,EAAO,KAAK,CAAC,GAChEE,IAAI,KAAK,IAAIF,EAAO,GAAG,KAAK,IAAIC,EAAK,GAAGD,EAAO,IAAIA,EAAO,MAAM,CAAC;CACvE,OAAO;EACL;EACA;EACA,OAAO,KAAK,IAAI,GAAG,KAAK,IAAIC,EAAK,IAAIA,EAAK,OAAOD,EAAO,IAAIA,EAAO,KAAK,IAAID,CAAC;EAC7E,QAAQ,KAAK,IAAI,GAAG,KAAK,IAAIE,EAAK,IAAIA,EAAK,QAAQD,EAAO,IAAIA,EAAO,MAAM,IAAIE,CAAC;CAClF;AACF;AAEA,SAAgBC,EAAuB,GAAwB,GAAwB;CAErF,OADIC,EAAE,SAAS,aAAaC,EAAE,SAAS,aAAaD,EAAE,SAASC,EAAE,OAAa,KAE5ED,EAAE,YAAY,WAAWC,EAAE,YAAY,UACvCD,EAAE,YAAY,WAAWC,EAAE,YAAY,UACvCD,EAAE,YAAY,aAAaC,EAAE,YAAY,YACzCD,EAAE,YAAY,UAAUC,EAAE,YAAY;AAE1C"}

package/dist/workspace/utils/interaction/insertion-offers.utils.d.ts

@@ -0,0 +1,58 @@
+import type { Rect } from '@nvidia-elements/core/internal';
+import { describePlacementSlot } from '../placement/group-insertion.utils.js';
+import type { WorkspacePlacedRegion } from '../geometry/allocation.utils.js';
+import type { WorkspaceDropIntent } from './drag-preview.utils.js';
+import type { WorkspaceLayout, WorkspaceNode } from '../model/layout.utils.js';
+import type { WorkspaceDestination } from '../model/operations.utils.js';
+import type { WorkspaceLayoutProjector } from '../model/projection.utils.js';
+import type { WorkspaceContextRectResolver } from '../placement/context.utils.js';
+import type { WorkspacePlacementPlan, WorkspacePlacementPlanner } from '../placement/planner.utils.js';
+export interface WorkspaceInsertionOffer {
+    kind: 'order' | 'insert';
+    owner: string;
+    boundary?: 'start' | 'end';
+    scope: NonNullable<ReturnType<typeof describePlacementSlot>>;
+    plan: WorkspacePlacementPlan;
+    rect: Rect;
+    hitRect?: Rect;
+    scopeRect: Rect;
+    destination: WorkspaceDestination;
+}
+/** Gives only an explicit peer lane or structural receiving endcap priority over chrome. */
+export declare function placementOwnsChrome(offer: WorkspaceInsertionOffer): boolean;
+export declare function findSourcePeerRegionKey(node: WorkspaceNode | null, source: string[], key?: string): string | undefined;
+/** Aliases of the same planned insertion share one descriptor. */
+export declare function createInsertionOffers(input: {
+    currentLayout: WorkspaceLayout;
+    root: WorkspaceNode | null;
+    source: string[];
+    available: string[];
+    projectLayout?: WorkspaceLayoutProjector;
+    planPlacement?: WorkspacePlacementPlanner;
+    contextRect?: WorkspaceContextRectResolver;
+    regions: WorkspacePlacedRegion[];
+    explorationRegions?: WorkspacePlacedRegion[];
+    existing: WorkspaceInsertionOffer[];
+    gap: number;
+}): WorkspaceInsertionOffer[];
+/** Shares the painted descriptor's exact operation with input resolution. */
+export declare function getPlacementOfferIntent(offer: WorkspaceInsertionOffer): WorkspaceDropIntent;
+/** Locates ordering availability in the computed exploration geometry, not a prospective landing. */
+export declare function getOrderHintRect(input: {
+    owner: Rect;
+    recipient: Rect;
+    previous?: Rect;
+    axis: 'horizontal' | 'vertical';
+    after: boolean;
+    sourceSlot?: Rect;
+    boundary?: 'start' | 'end';
+}): Rect | undefined;
+/** Orders overlapping scope offers into lanes from outermost to innermost. */
+export declare function partitionPlacementOffers(offers: WorkspaceInsertionOffer[]): WorkspaceInsertionOffer[];
+/** Uses current peer geometry for interior insertion cues, before allocating the candidate. */
+export declare function getCurrentInsertionSeam(offer: WorkspaceInsertionOffer, geometry: {
+    regions: WorkspacePlacedRegion[];
+    source: string[];
+    gap: number;
+    contextRect?: WorkspaceContextRectResolver;
+}): Rect | undefined;