@nvidia-elements/core 2.23.6 → 2.24.0

package/dist/dashboard/utils/geometry.utils.d.ts

@@ -0,0 +1,110 @@
+import type { Rect } from '@nvidia-elements/core/internal';
+import type { DashboardGridGeometry } from './intent.types.js';
+import type { DashboardGridPlacement, DashboardLayout, DashboardSpanConstraints } from '../dashboard.types.js';
+export interface DashboardMetrics {
+    readonly columnSize: number;
+    readonly rowSize: number;
+    /** Signed separation between outer cell boxes; negative means border overlap. */
+    readonly gap: number;
+    readonly width: number;
+    readonly height: number;
+}
+export declare function transposeDashboardGridGeometry(geometry: DashboardGridGeometry): DashboardGridGeometry;
+export declare function doDashboardGridGeometriesOverlap(left: DashboardGridGeometry, right: DashboardGridGeometry): boolean;
+interface DashboardMetricInput {
+    flow: DashboardLayout['grid']['flow'];
+    tracks: number;
+    sizing: 'fit' | 'fixed';
+    width: number;
+    height: number;
+    columnSize: number;
+    rowSize: number;
+    gap: number;
+    overlap: number;
+}
+export declare function resolveDashboardMetrics(input: DashboardMetricInput): DashboardMetrics | undefined;
+/** CSS-pixel placement measured from the canvas inline start and top. */
+export interface DashboardPixelPlacement {
+    readonly inlineStart: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+}
+export type DashboardReadingDirection = 'ltr' | 'rtl';
+export declare function getDashboardPixelPlacement(geometry: DashboardGridGeometry, metrics: DashboardMetrics): DashboardPixelPlacement;
+/** Projects logical canvas placement into physical client coordinates. */
+export declare function getDashboardPlacementClientRect(placement: DashboardPixelPlacement, canvasClientRect: Rect, readingDirection: DashboardReadingDirection): Rect;
+export declare function getProjectedControlRect(input: {
+    control: Rect;
+    current: Rect;
+    target: Rect;
+}, anchoredEdges: {
+    right: boolean;
+    bottom: boolean;
+}): Rect;
+export declare function getRevealScrollDelta(rect: Rect, viewport: Rect): {
+    x: number;
+    y: number;
+};
+export declare function getDashboardCanvasSize(input: {
+    layout: DashboardLayout;
+    metrics: DashboardMetrics;
+    sizing: 'fit' | 'fixed';
+    items: readonly DashboardGridPlacement[];
+    floor?: {
+        width: number;
+        height: number;
+    };
+}): {
+    width: number;
+    height: number;
+};
+export type DashboardResizeEdge = 'left' | 'right' | 'top' | 'bottom' | 'bottom-right' | 'bottom-left';
+interface ResizeAxisInput {
+    start: number;
+    span: number;
+    pixelStart: number;
+    pixelLength: number;
+    pixelDelta: number;
+    edge: 'minimum' | 'maximum' | 'none';
+    minimumSpan: number;
+    maximumSpan: number;
+    coordinateLimit: number;
+    /** Cell pitch and signed cell spacing, in CSS pixels. */
+    pitch: number;
+    gap: number;
+}
+/** Physical corner occupied by the panel's resize control. */
+export declare function getDashboardResizeCorner(panel: Element): 'bottom-left' | 'bottom-right';
+interface ResizeBoundaries {
+    readonly column: ResizeAxisInput['edge'];
+    readonly row: ResizeAxisInput['edge'];
+}
+/** Resolves physical edges against the grid's logical column direction. */
+export declare function getDashboardResizeBoundaries(edge: DashboardResizeEdge, readingDirection: DashboardReadingDirection): ResizeBoundaries;
+interface AnchoredResizeInput {
+    source: DashboardGridPlacement;
+    initialPixelPlacement: DashboardPixelPlacement;
+    delta: {
+        inline: number;
+        vertical: number;
+    };
+    edge: DashboardResizeEdge;
+    grid: DashboardLayout['grid'];
+    limits: DashboardSpanConstraints;
+    readingDirection: DashboardReadingDirection;
+}
+/** Keeps the opposite grid boundary fixed while resizing a physical edge. */
+export declare function getAnchoredResizeGeometry(input: AnchoredResizeInput, metrics: DashboardMetrics): {
+    geometry: DashboardGridPlacement;
+    canvasPlacement: DashboardPixelPlacement;
+};
+/** Validates resize semantics independently of ordinary movement permissions. */
+export declare function preservesDashboardResizeAnchors(source: DashboardGridPlacement, geometry: DashboardGridPlacement, options: {
+    edge: DashboardResizeEdge;
+    readingDirection: DashboardReadingDirection;
+}): boolean;
+export declare function isDashboardResizeEdge(value: string | undefined): value is DashboardResizeEdge;
+export declare function getDashboardClientRect(element: HTMLElement): Rect;
+export declare function haveSameGridPitch(left: DashboardMetrics | undefined, right: DashboardMetrics | undefined): boolean;
+export {};

package/dist/dashboard/utils/geometry.utils.js

@@ -0,0 +1,208 @@
+// src/dashboard/utils/geometry.utils.ts
+function e(e) {
+	return {
+		column: e.row,
+		row: e.column,
+		columnSpan: e.rowSpan,
+		rowSpan: e.columnSpan
+	};
+}
+function t(e, t) {
+	return e.column < t.column + t.columnSpan && t.column < e.column + e.columnSpan && e.row < t.row + t.rowSpan && t.row < e.row + e.rowSpan;
+}
+function n(e) {
+	let { flow: t, tracks: n, sizing: r, width: i, height: a } = e, o = e.gap - (e.gap === 0 ? e.overlap : 0);
+	if (!l(e)) return;
+	let s = r === "fit" && t === "vertical" ? (i - (n - 1) * o) / n : e.columnSize, c = r === "fit" && t === "horizontal" ? (a - (n - 1) * o) / n : e.rowSize;
+	if ([
+		s,
+		c,
+		s + o,
+		c + o
+	].every((e) => Number.isFinite(e) && e > 0)) return {
+		columnSize: s,
+		rowSize: c,
+		gap: o,
+		width: i,
+		height: a
+	};
+}
+function r(e, t) {
+	return {
+		inlineStart: e.column * (t.columnSize + t.gap),
+		top: e.row * (t.rowSize + t.gap),
+		width: e.columnSpan * t.columnSize + (e.columnSpan - 1) * t.gap,
+		height: e.rowSpan * t.rowSize + (e.rowSpan - 1) * t.gap
+	};
+}
+function i(e, t, n) {
+	return {
+		x: n === "rtl" ? t.x + t.width - e.inlineStart - e.width : t.x + e.inlineStart,
+		y: t.y + e.top,
+		width: e.width,
+		height: e.height
+	};
+}
+function a(e, t) {
+	let { control: n, current: r, target: i } = e;
+	return {
+		...n,
+		x: n.x + i.x - r.x + (t.right ? i.width - r.width : 0),
+		y: n.y + i.y - r.y + (t.bottom ? i.height - r.height : 0)
+	};
+}
+function o(e, t) {
+	return {
+		x: s({
+			start: e.x,
+			end: e.x + e.width,
+			low: t.x,
+			high: t.x + t.width
+		}),
+		y: s({
+			start: e.y,
+			end: e.y + e.height,
+			low: t.y,
+			high: t.y + t.height
+		})
+	};
+}
+function s(e) {
+	return e.start < e.low ? e.start - e.low : e.end > e.high ? e.end - e.high : 0;
+}
+function c(e) {
+	let { layout: t, metrics: n, sizing: i, items: a } = e, o = a.map((e) => r(e, n)), s = Math.max(n.width, e.floor?.width ?? 0, ...o.map((e) => e.inlineStart + e.width)), c = Math.max(n.height, e.floor?.height ?? 0, ...o.map((e) => e.top + e.height));
+	return t.grid.flow === "vertical" ? {
+		width: i === "fit" ? n.width : t.grid.tracks * (n.columnSize + n.gap) - n.gap,
+		height: c
+	} : {
+		width: s,
+		height: i === "fit" ? n.height : t.grid.tracks * (n.rowSize + n.gap) - n.gap
+	};
+}
+function l(e) {
+	return [
+		e.width,
+		e.height,
+		e.gap,
+		e.overlap
+	].every(Number.isFinite) && e.width > 0 && e.height > 0 && e.gap >= 0 && e.overlap >= 0 && Number.isSafeInteger(e.tracks) && e.tracks >= 1;
+}
+function u(e) {
+	return e.matches(":dir(rtl)") ? "bottom-left" : "bottom-right";
+}
+var d = {
+	left: {
+		column: "minimum",
+		row: "none"
+	},
+	right: {
+		column: "maximum",
+		row: "none"
+	},
+	top: {
+		column: "none",
+		row: "minimum"
+	},
+	bottom: {
+		column: "none",
+		row: "maximum"
+	},
+	"bottom-left": {
+		column: "minimum",
+		row: "maximum"
+	},
+	"bottom-right": {
+		column: "maximum",
+		row: "maximum"
+	}
+};
+function f(e, t) {
+	let n = d[e];
+	return t === "ltr" || n.column === "none" ? n : {
+		...n,
+		column: n.column === "minimum" ? "maximum" : "minimum"
+	};
+}
+function p(e, t) {
+	let { source: n, initialPixelPlacement: r, delta: i, edge: a, grid: o, limits: s } = e, c = f(a, e.readingDirection), l = m({
+		start: n.column,
+		span: n.columnSpan,
+		pixelStart: r.inlineStart,
+		pixelLength: r.width,
+		pixelDelta: i.inline,
+		edge: c.column,
+		minimumSpan: s.minColumnSpan,
+		maximumSpan: s.maxColumnSpan,
+		coordinateLimit: o.flow === "vertical" ? o.tracks : 1e6,
+		pitch: t.columnSize + t.gap,
+		gap: t.gap
+	}), u = m({
+		start: n.row,
+		span: n.rowSpan,
+		pixelStart: r.top,
+		pixelLength: r.height,
+		pixelDelta: i.vertical,
+		edge: c.row,
+		minimumSpan: s.minRowSpan,
+		maximumSpan: s.maxRowSpan,
+		coordinateLimit: o.flow === "horizontal" ? o.tracks : 1e6,
+		pitch: t.rowSize + t.gap,
+		gap: t.gap
+	});
+	return {
+		geometry: {
+			column: l.start,
+			row: u.start,
+			columnSpan: l.span,
+			rowSpan: u.span
+		},
+		canvasPlacement: {
+			inlineStart: l.pixelStart,
+			top: u.pixelStart,
+			width: l.pixelLength,
+			height: u.pixelLength
+		}
+	};
+}
+function m(e) {
+	let { start: t, span: n, pixelStart: r, pixelLength: i, pixelDelta: a, edge: o, minimumSpan: s, maximumSpan: c, coordinateLimit: l, pitch: u, gap: d } = e;
+	if (o === "none") return {
+		start: t,
+		span: n,
+		pixelStart: r,
+		pixelLength: i
+	};
+	let f = t + n, p = o === "minimum", m = Math.min(c, p ? f : l - t), h = Math.max(s * u - d, Math.min(m * u - d, i + (p ? -a : a))), g = p ? r + i - h : r, _ = n * u - d + (p ? -a : a), v = Math.round(p ? f - (_ + d) / u : t + (_ + d) / u), y = Math.max(s, Math.min(m, p ? f - v : v - t));
+	return {
+		start: p ? f - y : t,
+		span: y,
+		pixelStart: g,
+		pixelLength: h
+	};
+}
+function h(e, t, n) {
+	let r = f(n.edge, n.readingDirection);
+	return ["column", "row"].every((n) => {
+		let i = n === "column" ? "columnSpan" : "rowSpan";
+		return (r[n] === "maximum" || e[n] + e[i] === t[n] + t[i]) && (r[n] === "minimum" || e[n] === t[n]);
+	});
+}
+function g(e) {
+	return e === "left" || e === "right" || e === "top" || e === "bottom" || e === "bottom-right" || e === "bottom-left";
+}
+function _(e) {
+	let t = e.getBoundingClientRect();
+	return {
+		x: t.left,
+		y: t.top,
+		width: t.width,
+		height: t.height
+	};
+}
+function v(e, t) {
+	return !!e && !!t && e.columnSize === t.columnSize && e.rowSize === t.rowSize && e.gap === t.gap;
+}
+export { t as doDashboardGridGeometriesOverlap, p as getAnchoredResizeGeometry, c as getDashboardCanvasSize, _ as getDashboardClientRect, r as getDashboardPixelPlacement, i as getDashboardPlacementClientRect, f as getDashboardResizeBoundaries, u as getDashboardResizeCorner, a as getProjectedControlRect, o as getRevealScrollDelta, v as haveSameGridPitch, g as isDashboardResizeEdge, h as preservesDashboardResizeAnchors, n as resolveDashboardMetrics, e as transposeDashboardGridGeometry };
+
+//# sourceMappingURL=geometry.utils.js.map

package/dist/dashboard/utils/geometry.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.utils.js","names":["transposeDashboardGridGeometry","geometry","doDashboardGridGeometriesOverlap","left","right","resolveDashboardMetrics","input","gap","isMetricInputValid","columnSize","sizing","flow","width","tracks","rowSize","height","value","getDashboardPixelPlacement","metrics","getDashboardPlacementClientRect","readingDirection","canvasClientRect","placement","getProjectedControlRect","control","target","current","anchoredEdges","getRevealScrollDelta","getNearestScrollDelta","rect","viewport","getDashboardCanvasSize","pixels","items","item","bottom","layout","getDashboardResizeCorner","panel","resizeBoundaries","getDashboardResizeBoundaries","physical","edge","getAnchoredResizeGeometry","boundaries","horizontal","resizeAxis","source","initialPixelPlacement","delta","limits","grid","vertical","end","start","span","leading","maxSpan","maximumSpan","coordinateLimit","rawLength","minimumSpan","pitch","pixelLength","pixelDelta","rawStart","pixelStart","logicalLength","boundary","size","preservesDashboardResizeAnchors","options","axis","isDashboardResizeEdge","getDashboardClientRect","element","haveSameGridPitch"],"sources":["../../../src/dashboard/utils/geometry.utils.ts"],"sourcesContent":["// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Rect } from '@nvidia-elements/core/internal';\n\nimport type { DashboardGridGeometry } from './intent.types.js';\n\nimport type { DashboardGridPlacement, DashboardLayout, DashboardSpanConstraints } from '../dashboard.types.js';\n\nexport interface DashboardMetrics {\n  readonly columnSize: number;\n  readonly rowSize: number;\n  /** Signed separation between outer cell boxes; negative means border overlap. */\n  readonly gap: number;\n  readonly width: number;\n  readonly height: number;\n}\n\nexport function transposeDashboardGridGeometry(geometry: DashboardGridGeometry): DashboardGridGeometry {\n  return { column: geometry.row, row: geometry.column, columnSpan: geometry.rowSpan, rowSpan: geometry.columnSpan };\n}\n\nexport function doDashboardGridGeometriesOverlap(left: DashboardGridGeometry, right: DashboardGridGeometry): boolean {\n  return (\n    left.column < right.column + right.columnSpan &&\n    right.column < left.column + left.columnSpan &&\n    left.row < right.row + right.rowSpan &&\n    right.row < left.row + left.rowSpan\n  );\n}\n\ninterface DashboardMetricInput {\n  flow: DashboardLayout['grid']['flow'];\n  tracks: number;\n  sizing: 'fit' | 'fixed';\n  width: number;\n  height: number;\n  columnSize: number;\n  rowSize: number;\n  gap: number;\n  overlap: number;\n}\n\nexport function resolveDashboardMetrics(input: DashboardMetricInput): DashboardMetrics | undefined {\n  const { flow, tracks, sizing, width, height } = input;\n  const gap = input.gap - (input.gap === 0 ? input.overlap : 0);\n  if (!isMetricInputValid(input)) return undefined;\n\n  const columnSize = sizing === 'fit' && flow === 'vertical' ? (width - (tracks - 1) * gap) / tracks : input.columnSize;\n  const rowSize = sizing === 'fit' && flow === 'horizontal' ? (height - (tracks - 1) * gap) / tracks : input.rowSize;\n  if (![columnSize, rowSize, columnSize + gap, rowSize + gap].every(value => Number.isFinite(value) && value > 0)) {\n    return undefined;\n  }\n\n  return { columnSize, rowSize, gap, width, height };\n}\n\n/** CSS-pixel placement measured from the canvas inline start and top. */\nexport interface DashboardPixelPlacement {\n  readonly inlineStart: number;\n  readonly top: number;\n  readonly width: number;\n  readonly height: number;\n}\n\nexport type DashboardReadingDirection = 'ltr' | 'rtl';\n\nexport function getDashboardPixelPlacement(\n  geometry: DashboardGridGeometry,\n  metrics: DashboardMetrics\n): DashboardPixelPlacement {\n  return {\n    inlineStart: geometry.column * (metrics.columnSize + metrics.gap),\n    top: geometry.row * (metrics.rowSize + metrics.gap),\n    width: geometry.columnSpan * metrics.columnSize + (geometry.columnSpan - 1) * metrics.gap,\n    height: geometry.rowSpan * metrics.rowSize + (geometry.rowSpan - 1) * metrics.gap\n  };\n}\n\n/** Projects logical canvas placement into physical client coordinates. */\nexport function getDashboardPlacementClientRect(\n  placement: DashboardPixelPlacement,\n  canvasClientRect: Rect,\n  readingDirection: DashboardReadingDirection\n): Rect {\n  return {\n    x:\n      readingDirection === 'rtl'\n        ? canvasClientRect.x + canvasClientRect.width - placement.inlineStart - placement.width\n        : canvasClientRect.x + placement.inlineStart,\n    y: canvasClientRect.y + placement.top,\n    width: placement.width,\n    height: placement.height\n  };\n}\n\nexport function getProjectedControlRect(\n  input: { control: Rect; current: Rect; target: Rect },\n  anchoredEdges: { right: boolean; bottom: boolean }\n): Rect {\n  const { control, current, target } = input;\n  return {\n    ...control,\n    x: control.x + target.x - current.x + (anchoredEdges.right ? target.width - current.width : 0),\n    y: control.y + target.y - current.y + (anchoredEdges.bottom ? target.height - current.height : 0)\n  };\n}\n\nexport function getRevealScrollDelta(rect: Rect, viewport: Rect): { x: number; y: number } {\n  return {\n    x: getNearestScrollDelta({\n      start: rect.x,\n      end: rect.x + rect.width,\n      low: viewport.x,\n      high: viewport.x + viewport.width\n    }),\n    y: getNearestScrollDelta({\n      start: rect.y,\n      end: rect.y + rect.height,\n      low: viewport.y,\n      high: viewport.y + viewport.height\n    })\n  };\n}\n\nfunction getNearestScrollDelta(input: { start: number; end: number; low: number; high: number }): number {\n  if (input.start < input.low) return input.start - input.low;\n  if (input.end > input.high) return input.end - input.high;\n\n  return 0;\n}\n\nexport function getDashboardCanvasSize(input: {\n  layout: DashboardLayout;\n  metrics: DashboardMetrics;\n  sizing: 'fit' | 'fixed';\n  items: readonly DashboardGridPlacement[];\n  floor?: { width: number; height: number };\n}): { width: number; height: number } {\n  const { layout, metrics, sizing, items } = input;\n  const pixels = items.map(item => getDashboardPixelPlacement(item, metrics));\n  const right = Math.max(metrics.width, input.floor?.width ?? 0, ...pixels.map(item => item.inlineStart + item.width));\n  const bottom = Math.max(metrics.height, input.floor?.height ?? 0, ...pixels.map(item => item.top + item.height));\n\n  if (layout.grid.flow === 'vertical') {\n    const boundedWidth =\n      sizing === 'fit' ? metrics.width : layout.grid.tracks * (metrics.columnSize + metrics.gap) - metrics.gap;\n\n    return { width: boundedWidth, height: bottom };\n  }\n\n  const boundedHeight =\n    sizing === 'fit' ? metrics.height : layout.grid.tracks * (metrics.rowSize + metrics.gap) - metrics.gap;\n\n  return { width: right, height: boundedHeight };\n}\n\nfunction isMetricInputValid(input: DashboardMetricInput): boolean {\n  return (\n    [input.width, input.height, input.gap, input.overlap].every(Number.isFinite) &&\n    input.width > 0 &&\n    input.height > 0 &&\n    input.gap >= 0 &&\n    input.overlap >= 0 &&\n    Number.isSafeInteger(input.tracks) &&\n    input.tracks >= 1\n  );\n}\n\nexport type DashboardResizeEdge = 'left' | 'right' | 'top' | 'bottom' | 'bottom-right' | 'bottom-left';\n\ninterface ResizeAxisInput {\n  start: number;\n  span: number;\n  pixelStart: number;\n  pixelLength: number;\n  pixelDelta: number;\n  edge: 'minimum' | 'maximum' | 'none';\n  minimumSpan: number;\n  maximumSpan: number;\n  coordinateLimit: number;\n  /** Cell pitch and signed cell spacing, in CSS pixels. */\n  pitch: number;\n  gap: number;\n}\n\n/** Physical corner occupied by the panel's resize control. */\nexport function getDashboardResizeCorner(panel: Element): 'bottom-left' | 'bottom-right' {\n  return panel.matches(':dir(rtl)') ? 'bottom-left' : 'bottom-right';\n}\n\ninterface ResizeBoundaries {\n  readonly column: ResizeAxisInput['edge'];\n  readonly row: ResizeAxisInput['edge'];\n}\n\nconst resizeBoundaries: Readonly<Record<DashboardResizeEdge, ResizeBoundaries>> = {\n  left: { column: 'minimum', row: 'none' },\n  right: { column: 'maximum', row: 'none' },\n  top: { column: 'none', row: 'minimum' },\n  bottom: { column: 'none', row: 'maximum' },\n  'bottom-left': { column: 'minimum', row: 'maximum' },\n  'bottom-right': { column: 'maximum', row: 'maximum' }\n};\n\n/** Resolves physical edges against the grid's logical column direction. */\nexport function getDashboardResizeBoundaries(\n  edge: DashboardResizeEdge,\n  readingDirection: DashboardReadingDirection\n): ResizeBoundaries {\n  const physical = resizeBoundaries[edge];\n  if (readingDirection === 'ltr' || physical.column === 'none') return physical;\n\n  return { ...physical, column: physical.column === 'minimum' ? 'maximum' : 'minimum' };\n}\n\ninterface AnchoredResizeInput {\n  source: DashboardGridPlacement;\n  initialPixelPlacement: DashboardPixelPlacement;\n  delta: { inline: number; vertical: number };\n  edge: DashboardResizeEdge;\n  grid: DashboardLayout['grid'];\n  limits: DashboardSpanConstraints;\n  readingDirection: DashboardReadingDirection;\n}\n\n/** Keeps the opposite grid boundary fixed while resizing a physical edge. */\nexport function getAnchoredResizeGeometry(\n  input: AnchoredResizeInput,\n  metrics: DashboardMetrics\n): { geometry: DashboardGridPlacement; canvasPlacement: DashboardPixelPlacement } {\n  const { source, initialPixelPlacement, delta, edge, grid, limits } = input;\n  const boundaries = getDashboardResizeBoundaries(edge, input.readingDirection);\n  const horizontal = resizeAxis({\n    start: source.column,\n    span: source.columnSpan,\n    pixelStart: initialPixelPlacement.inlineStart,\n    pixelLength: initialPixelPlacement.width,\n    pixelDelta: delta.inline,\n    edge: boundaries.column,\n    minimumSpan: limits.minColumnSpan,\n    maximumSpan: limits.maxColumnSpan,\n    coordinateLimit: grid.flow === 'vertical' ? grid.tracks : 1_000_000,\n    pitch: metrics.columnSize + metrics.gap,\n    gap: metrics.gap\n  });\n  const vertical = resizeAxis({\n    start: source.row,\n    span: source.rowSpan,\n    pixelStart: initialPixelPlacement.top,\n    pixelLength: initialPixelPlacement.height,\n    pixelDelta: delta.vertical,\n    edge: boundaries.row,\n    minimumSpan: limits.minRowSpan,\n    maximumSpan: limits.maxRowSpan,\n    coordinateLimit: grid.flow === 'horizontal' ? grid.tracks : 1_000_000,\n    pitch: metrics.rowSize + metrics.gap,\n    gap: metrics.gap\n  });\n\n  return {\n    geometry: { column: horizontal.start, row: vertical.start, columnSpan: horizontal.span, rowSpan: vertical.span },\n    canvasPlacement: {\n      inlineStart: horizontal.pixelStart,\n      top: vertical.pixelStart,\n      width: horizontal.pixelLength,\n      height: vertical.pixelLength\n    }\n  };\n}\n\nfunction resizeAxis(input: ResizeAxisInput) {\n  const {\n    start,\n    span,\n    pixelStart,\n    pixelLength,\n    pixelDelta,\n    edge,\n    minimumSpan,\n    maximumSpan,\n    coordinateLimit,\n    pitch,\n    gap\n  } = input;\n  if (edge === 'none') return { start, span, pixelStart, pixelLength };\n\n  const end = start + span;\n  const leading = edge === 'minimum';\n  const maxSpan = Math.min(maximumSpan, leading ? end : coordinateLimit - start);\n  const rawLength = Math.max(\n    minimumSpan * pitch - gap,\n    Math.min(maxSpan * pitch - gap, pixelLength + (leading ? -pixelDelta : pixelDelta))\n  );\n  const rawStart = leading ? pixelStart + pixelLength - rawLength : pixelStart;\n  const logicalLength = span * pitch - gap + (leading ? -pixelDelta : pixelDelta);\n  const boundary = Math.round(leading ? end - (logicalLength + gap) / pitch : start + (logicalLength + gap) / pitch);\n  const size = Math.max(minimumSpan, Math.min(maxSpan, leading ? end - boundary : boundary - start));\n\n  return { start: leading ? end - size : start, span: size, pixelStart: rawStart, pixelLength: rawLength };\n}\n\n/** Validates resize semantics independently of ordinary movement permissions. */\nexport function preservesDashboardResizeAnchors(\n  source: DashboardGridPlacement,\n  geometry: DashboardGridPlacement,\n  options: { edge: DashboardResizeEdge; readingDirection: DashboardReadingDirection }\n): boolean {\n  const boundaries = getDashboardResizeBoundaries(options.edge, options.readingDirection);\n  return (['column', 'row'] as const).every(axis => {\n    const span = axis === 'column' ? 'columnSpan' : 'rowSpan';\n    return (\n      (boundaries[axis] === 'maximum' || source[axis] + source[span] === geometry[axis] + geometry[span]) &&\n      (boundaries[axis] === 'minimum' || source[axis] === geometry[axis])\n    );\n  });\n}\n\nexport function isDashboardResizeEdge(value: string | undefined): value is DashboardResizeEdge {\n  return (\n    value === 'left' ||\n    value === 'right' ||\n    value === 'top' ||\n    value === 'bottom' ||\n    value === 'bottom-right' ||\n    value === 'bottom-left'\n  );\n}\n\nexport function getDashboardClientRect(element: HTMLElement): Rect {\n  const rect = element.getBoundingClientRect();\n  return { x: rect.left, y: rect.top, width: rect.width, height: rect.height };\n}\n\nexport function haveSameGridPitch(left: DashboardMetrics | undefined, right: DashboardMetrics | undefined): boolean {\n  return (\n    !!left &&\n    !!right &&\n    left.columnSize === right.columnSize &&\n    left.rowSize === right.rowSize &&\n    left.gap === right.gap\n  );\n}\n"],"mappings":"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"}

package/dist/dashboard/utils/intent.types.d.ts

@@ -0,0 +1,67 @@
+import type { DashboardResizeEdge } from './geometry.utils.js';
+/** Continuous grid-cell geometry used while interpreting pointer movement. */
+export interface DashboardGridGeometry {
+    readonly column: number;
+    readonly row: number;
+    readonly columnSpan: number;
+    readonly rowSpan: number;
+}
+export type DashboardAction = 'move' | 'resize';
+export type DashboardAxis = 'column' | 'row';
+export type DashboardAxisDirection = -1 | 1;
+export interface DashboardGridPoint {
+    readonly column: number;
+    readonly row: number;
+}
+/** Pointer coordinates and spacing use cell pitches. */
+export interface DashboardPointerPlacementQuery {
+    readonly aimGeometry: DashboardGridGeometry;
+    readonly pointerPosition: DashboardGridPoint;
+    readonly spacingFraction: DashboardGridPoint;
+}
+/** Semantic input after command and gesture permission checks. */
+export type DashboardIntent = {
+    readonly kind: 'coordinate';
+    readonly geometry: DashboardGridGeometry;
+} | {
+    readonly kind: 'pointer';
+    readonly geometry: DashboardGridGeometry;
+    readonly position: DashboardPointerPlacementQuery;
+} | {
+    readonly kind: 'advance';
+    readonly geometry: DashboardGridGeometry;
+    readonly step: DashboardGridPoint;
+} | {
+    readonly kind: 'start';
+    readonly geometry: DashboardGridGeometry;
+} | {
+    readonly kind: 'resize';
+    readonly geometry: DashboardGridGeometry;
+};
+/** Pointer admission uses the same complete request for replay. */
+export type DashboardPointerIntent = {
+    readonly kind: 'pointer';
+    readonly geometry: DashboardGridGeometry;
+    readonly position: DashboardPointerPlacementQuery;
+} | {
+    readonly kind: 'start';
+    readonly geometry: DashboardGridGeometry;
+} | {
+    readonly kind: 'anchored-resize';
+    readonly geometry: DashboardGridGeometry;
+    readonly edge: DashboardResizeEdge;
+};
+export type DashboardArrangementRequest = {
+    readonly kind: 'command';
+    readonly command: string;
+    readonly placement?: unknown;
+} | DashboardPointerIntent;
+export type DashboardCommandEvent = Event & {
+    command?: string;
+    source?: HTMLElement & {
+        value?: string;
+        placement?: unknown;
+        disabled?: boolean;
+        readOnly?: boolean;
+    };
+};

package/dist/dashboard/utils/layout.utils.d.ts

@@ -0,0 +1,20 @@
+import type { DashboardIntent } from './intent.types.js';
+import type { DashboardGridPlacement, DashboardItem, DashboardLayout, DashboardSpanConstraints } from '../dashboard.types.js';
+export declare function isDashboardGridPlacement(value: unknown): value is DashboardGridPlacement;
+export declare function parseDashboardValue(value: string): DashboardLayout | undefined;
+export declare function serializeDashboardValue(layout: DashboardLayout | undefined): string;
+export declare function createDefaultDashboardLayout(): DashboardLayout;
+/** Reconciles current members; hidden members keep placement without occupying cells. */
+export declare function reconcileDashboard(layout: DashboardLayout, panels: readonly DashboardSpanConstraints[], options?: {
+    priority?: ReadonlySet<string>;
+    autoSettle?: boolean;
+    hidden?: ReadonlySet<string>;
+}): DashboardLayout | undefined;
+/** Searches occupied boundaries, so sparse coordinate distances do not increase work. */
+export declare function findFirstDashboardFit(item: DashboardItem, occupied: readonly DashboardItem[], grid: DashboardLayout['grid']): DashboardItem | undefined;
+/** Resolves directional placement collisions and optionally settles supplied panels toward the growth-axis origin. */
+export declare function placeDashboard(layout: DashboardLayout, panels: readonly DashboardSpanConstraints[], request: {
+    readonly id: string;
+    readonly intent: DashboardIntent;
+    readonly autoSettle?: boolean;
+}): DashboardLayout | undefined;

package/dist/dashboard/utils/layout.utils.js

@@ -0,0 +1,224 @@
+import { doDashboardGridGeometriesOverlap as e, transposeDashboardGridGeometry as t } from "./geometry.utils.js";
+import { findNormalizedPlacementPlan as n, orientDashboardItem as r, settleDashboardItems as i } from "./packing.utils.js";
+// src/dashboard/utils/layout.utils.ts
+var a = 1e6;
+function o(e) {
+	return T(e) ? w(e.column, 0) && w(e.row, 0) && w(e.columnSpan, 1) && w(e.rowSpan, 1) && e.column + e.columnSpan <= a && e.row + e.rowSpan <= a : !1;
+}
+function s(e) {
+	if (!e) return;
+	let t = JSON.parse(e);
+	T(t) && t.version === 1 && Array.isArray(t.items) || u();
+	let n = c(t.grid), r = /* @__PURE__ */ new Set();
+	return {
+		version: 1,
+		grid: n,
+		items: t.items.map((e) => l(e, n, r))
+	};
+}
+function c(e) {
+	return (!T(e) || e.flow !== "vertical" && e.flow !== "horizontal" || !w(e.tracks, 1)) && u(), {
+		flow: e.flow,
+		tracks: e.tracks
+	};
+}
+function l(e, t, n) {
+	return T(e) && o(e) && "id" in e && typeof e.id == "string" && e.id && !n.has(e.id) || u(), (t.flow === "vertical" ? e.column + e.columnSpan : e.row + e.rowSpan) > t.tracks && u(), n.add(e.id), {
+		id: e.id,
+		column: e.column,
+		row: e.row,
+		columnSpan: e.columnSpan,
+		rowSpan: e.rowSpan
+	};
+}
+function u() {
+	throw TypeError("Invalid dashboard arrangement");
+}
+function d(e) {
+	return e ? JSON.stringify(e) : "";
+}
+function f() {
+	return {
+		version: 1,
+		grid: {
+			flow: "vertical",
+			tracks: 12
+		},
+		items: []
+	};
+}
+function p(e, t, n = {}) {
+	let a = new Map(t.map((e) => [e.id, e]));
+	if (a.size !== t.length || t.some((e) => !e.id)) return;
+	let o = h({
+		layout: e,
+		available: a,
+		priority: n.priority,
+		hidden: n.hidden
+	}), s = o && m({
+		...o,
+		available: a,
+		grid: e.grid,
+		hidden: n.hidden
+	});
+	if (!s) return;
+	let { active: c, items: l } = s, u = c.map((t) => r(t, e.grid.flow)), d = n.autoSettle ? i(u) : u;
+	if (!d) return;
+	let f = new Map(d.map((t) => [t.id, r(t, e.grid.flow)]));
+	return {
+		version: 1,
+		grid: e.grid,
+		items: l.map((e) => f.get(e.id) ?? e)
+	};
+}
+function m(e) {
+	let { available: t, grid: n, active: r, items: i, hidden: a } = e;
+	for (let e of t.values()) {
+		let t = {
+			id: e.id,
+			column: 0,
+			row: 0,
+			columnSpan: 1,
+			rowSpan: 1
+		}, o = a?.has(e.id) ? t : g({
+			item: t,
+			limits: e,
+			grid: n,
+			active: r
+		});
+		if (!o) return;
+		a?.has(e.id) || r.push(o), i.push(o);
+	}
+	return {
+		active: r,
+		items: i
+	};
+}
+function h(e) {
+	let { layout: t, available: n, priority: r, hidden: i } = e, a = [], o = /* @__PURE__ */ new Map(), s = r ? [...t.items.filter((e) => r.has(e.id)), ...t.items.filter((e) => !r.has(e.id))] : t.items;
+	for (let e of s) {
+		let r = n.get(e.id);
+		if (!r) continue;
+		n.delete(e.id);
+		let s = i?.has(e.id) ? e : g({
+			item: e,
+			limits: r,
+			grid: t.grid,
+			active: a
+		});
+		if (!s) return;
+		i?.has(e.id) || a.push(s), o.set(s.id, s);
+	}
+	return {
+		active: a,
+		items: t.items.flatMap((e) => o.get(e.id) ?? [])
+	};
+}
+function g(t) {
+	let { item: n, limits: r, grid: i, active: a } = t;
+	if (!C(r)) return;
+	let s = Math.max(r.minColumnSpan, Math.min(r.maxColumnSpan, n.columnSpan)), c = Math.max(r.minRowSpan, Math.min(r.maxRowSpan, n.rowSpan)), l = {
+		...n,
+		columnSpan: s,
+		rowSpan: c
+	};
+	if (!((i.flow === "vertical" ? s : c) > i.tracks)) return o(l) && (i.flow === "vertical" ? l.column + s : l.row + c) <= i.tracks && a.every((t) => !e(t, l)) ? l : _(l, a, i);
+}
+function _(t, n, r) {
+	let i = S(t, r.flow);
+	if (i.columnSpan > r.tracks) return;
+	let a = n.map((e) => S(e, r.flow)), s = [.../* @__PURE__ */ new Set([0, ...a.map((e) => e.row + e.rowSpan)])].sort((e, t) => e - t), c = [.../* @__PURE__ */ new Set([0, ...a.map((e) => e.column + e.columnSpan)])].sort((e, t) => e - t);
+	for (let n of s) for (let s of c) {
+		let c = {
+			...i,
+			column: s,
+			row: n
+		};
+		if (s + i.columnSpan <= r.tracks && o(c) && a.every((t) => !e(c, t))) return {
+			id: t.id,
+			...S(c, r.flow)
+		};
+	}
+}
+function v(e, t, i) {
+	let { id: a, intent: o } = i, s = o.geometry, c = e.items.find((e) => e.id === a), l = t.find((e) => e.id === a), u = S(s, e.grid.flow);
+	if (!c || !l || !x(s, l) || u.column + u.columnSpan > e.grid.tracks) return;
+	let d = new Set(t.map((e) => e.id)), f = e.items.filter((e) => d.has(e.id)).map((t) => r(t, e.grid.flow)), p = y(o, c, e.grid.flow), m = n(f, {
+		id: a,
+		intent: p
+	}, {
+		tracks: e.grid.tracks,
+		autoSettle: i.autoSettle
+	});
+	if (!m) return;
+	let h = new Map(m.map((t) => [t.id, r(t, e.grid.flow)]));
+	return {
+		...e,
+		items: e.items.map((e) => h.get(e.id) ?? e)
+	};
+}
+function y(e, t, n) {
+	if (e.kind === "start") return b(e, n);
+	let r = S(e.geometry, n);
+	return t.columnSpan !== e.geometry.columnSpan || t.rowSpan !== e.geometry.rowSpan ? {
+		kind: "resize",
+		geometry: r
+	} : e.kind === "resize" ? {
+		kind: "coordinate",
+		geometry: r
+	} : b(e, n);
+}
+function b(e, t) {
+	let n = S(e.geometry, t), r = (e) => t === "vertical" ? e : {
+		column: e.row,
+		row: e.column
+	};
+	switch (e.kind) {
+		case "coordinate": return {
+			kind: "coordinate",
+			geometry: n
+		};
+		case "start": return {
+			kind: "start",
+			geometry: n
+		};
+		case "pointer": return {
+			kind: "pointer",
+			geometry: n,
+			position: {
+				aimGeometry: S(e.position.aimGeometry, t),
+				pointerPosition: r(e.position.pointerPosition),
+				spacingFraction: r(e.position.spacingFraction)
+			}
+		};
+		case "advance": return {
+			kind: "advance",
+			geometry: n,
+			step: r(e.step)
+		};
+		default: return e;
+	}
+}
+function x(e, t) {
+	return o(e) && C(t) && e.columnSpan >= t.minColumnSpan && e.rowSpan >= t.minRowSpan && e.columnSpan <= t.maxColumnSpan && e.rowSpan <= t.maxRowSpan;
+}
+function S(e, n) {
+	return n === "vertical" ? {
+		column: e.column,
+		row: e.row,
+		columnSpan: e.columnSpan,
+		rowSpan: e.rowSpan
+	} : t(e);
+}
+function C(e) {
+	return w(e.minColumnSpan, 1) && w(e.minRowSpan, 1) && w(e.maxColumnSpan, 1) && w(e.maxRowSpan, 1) && e.minColumnSpan <= e.maxColumnSpan && e.minRowSpan <= e.maxRowSpan;
+}
+function w(e, t) {
+	return typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= a;
+}
+function T(e) {
+	return typeof e == "object" && !!e;
+}
+export { f as createDefaultDashboardLayout, _ as findFirstDashboardFit, o as isDashboardGridPlacement, s as parseDashboardValue, v as placeDashboard, p as reconcileDashboard, d as serializeDashboardValue };
+
+//# sourceMappingURL=layout.utils.js.map