regular-layout 0.2.1 → 0.3.0

package/dist/layout/calculate_edge.d.ts

@@ -2,7 +2,7 @@ import { type Physics } from "./constants";
 import type { Layout, LayoutPath } from "./types";
 /**
  * Calculates an insertion point (which may involve splitting a single
- * `"child-panel"` into a new `"split-panel"`), based on the  cursor position.
+ * `"tab-layout"` into a new `"split-layout"`), based on the  cursor position.
  * *
  * @param col - The cursor column.
  * @param row - The cursor row.
@@ -10,7 +10,7 @@ import type { Layout, LayoutPath } from "./types";
  * @param slot - The slot identifier where the insert should occur
  * @param drop_target - The `LayoutPath` (from `calculateIntersect`) of the
  * panel to either insert next to, or split by.
- * @returns A new `LayoutPath` reflecting the updated (maybe) `"split-panel"`,
+ * @returns A new `LayoutPath` reflecting the updated (maybe) `"split-layout"`,
  * which is enough to draw the overlay.
  */
 export declare function calculate_edge(col: number, row: number, panel: Layout, slot: string, drop_target: LayoutPath, box?: DOMRect, physics?: Physics): LayoutPath;

package/dist/layout/calculate_path.d.ts

@@ -0,0 +1,12 @@
+import type { Layout } from "./types.ts";
+/**
+ * Calculates the index path for a panel with the given name.
+ *
+ * Traverses the layout tree to find the named panel and returns the
+ * index path describing its position in the tree.
+ *
+ * @param name - The name of the panel to find.
+ * @param layout - The layout tree to search.
+ * @returns The panel's index path if found, `null` otherwise.
+ */
+export declare function calculate_path(name: string, layout: Layout): number[] | null;

package/dist/layout/generate_grid.d.ts

@@ -14,11 +14,11 @@ import type { Layout } from "./types.ts";
  * @example
  * ```typescript
  * const layout = {
- *   type: "split-panel",
+ *   type: "split-layout",
  *   orientation: "horizontal",
  *   children: [
- *     { type: "child-panel", child: "sidebar" },
- *     { type: "child-panel", child: "main" }
+ *     { type: "tab-layout", tabs: "sidebar" },
+ *     { type: "tab-layout", tabs: "main" }
  *   ],
  *   sizes: [0.25, 0.75]
  * };

package/dist/layout/generate_overlay.d.ts

@@ -1,2 +1,2 @@
 import type { LayoutPath } from "./types";
-export declare function updateOverlaySheet(slot: string, box: DOMRect, style: CSSStyleDeclaration, drag_target: LayoutPath<undefined> | null, physics?: import("./constants").Physics): string;
+export declare function updateOverlaySheet(slot: string, box: DOMRect, style: CSSStyleDeclaration, drag_target: LayoutPath | null, physics?: import("./constants").Physics): string;

package/dist/layout/insert_child.d.ts

@@ -1,4 +1,4 @@
-import type { Layout } from "./types.ts";
+import type { Layout, LayoutPathTraversal } from "./types.ts";
 /**
  * Inserts a new child panel into the layout tree at a specified location.
  * Creates a split panel if necessary and redistributes sizes equally among all
@@ -13,4 +13,4 @@ import type { Layout } from "./types.ts";
  * @param is_edge - If true, create the split at the parent level.
  * @returns A new layout tree with the child inserted (original is not mutated).
  */
-export declare function insert_child(panel: Layout, child: string, path: number[], orientation?: "horizontal" | "vertical"): Layout;
+export declare function insert_child(panel: Layout, child: string, path: LayoutPathTraversal, orientation?: "horizontal" | "vertical"): Layout;

package/dist/layout/redistribute_panel_sizes.d.ts

@@ -1,4 +1,4 @@
-import type { Layout } from "./types.ts";
+import type { Layout, LayoutPathTraversal } from "./types.ts";
 /**
  * Adjusts panel sizes during a drag operation on a divider.
  *
@@ -16,4 +16,4 @@ import type { Layout } from "./types.ts";
  * @returns A new layout tree with updated sizes (original is not mutated).
  * ```
  */
-export declare function redistribute_panel_sizes(panel: Layout, path: number[], delta: number, physics?: import("./constants.ts").Physics): Layout;
+export declare function redistribute_panel_sizes(panel: Layout, path: LayoutPathTraversal, delta: number | undefined, physics?: import("./constants.ts").Physics): Layout;

package/dist/layout/types.d.ts

@@ -32,7 +32,7 @@ export interface ViewWindow {
  * opposite `orientation` as its parent.
  */
 export interface SplitLayout {
-    type: "split-panel";
+    type: "split-layout";
     children: Layout[];
     sizes: number[];
     orientation: Orientation;
@@ -41,31 +41,31 @@ export interface SplitLayout {
  * A leaf panel node that contains a single named child element.
  */
 export interface TabLayout {
-    type: "child-panel";
-    child: string[];
+    type: "tab-layout";
+    tabs: string[];
     selected?: number;
 }
+/**
+ * Represents a panel location relative to a `Layout` struct.
+ */
+export type LayoutPathTraversal = number[];
 /**
  * Represents a draggable divider between two panels in the layout.
  *
  * Used for hit detection.
  */
 export interface LayoutDivider {
-    path: number[];
+    path: LayoutPathTraversal;
     view_window: ViewWindow;
     type: Orientation;
 }
 /**
  * Represents a panel location result from hit detection.
- *
- * Contains both the panel identifier and its grid position in relative units.
- * The generic parameter `T` allows DOM-only properties (e.g. `DOMRect`) to be
- * shared in this cross-platform module.
  */
-export interface LayoutPath<T = undefined> {
+export interface LayoutPath {
     type: "layout-path";
     slot: string;
-    path: number[];
+    path: LayoutPathTraversal;
     view_window: ViewWindow;
     column: number;
     row: number;
@@ -73,7 +73,7 @@ export interface LayoutPath<T = undefined> {
     row_offset: number;
     orientation: Orientation;
     is_edge: boolean;
-    layout: T;
+    layout: Layout;
 }
 /**
  * An empty `Layout` with no panels.

package/dist/regular-layout-frame.d.ts

@@ -28,15 +28,22 @@ export declare class RegularLayoutFrame extends HTMLElement {
     private _container_sheet;
     private _layout;
     private _header;
-    private _drag_state;
-    private _drag_moved;
+    private _drag;
     private _tab_to_index_map;
-    constructor();
+    /**
+     * Initializes this elements. Override this method and
+     * `disconnectedCallback` to modify how this subclass renders the Shadow
+     * DOM and registers events.
+     */
     connectedCallback(): void;
+    /**
+     * Destroys this element.
+     */
     disconnectedCallback(): void;
     private onPointerDown;
     private onPointerMove;
     private onPointerUp;
+    private onPointerCancel;
     private onPointerLost;
     private drawTabs;
 }

package/dist/regular-layout.d.ts

@@ -1,5 +1,14 @@
-import type { LayoutPath, Layout, TabLayout, OverlayMode, Orientation } from "./layout/types.ts";
+import type { LayoutPath, Layout, TabLayout, OverlayMode, Orientation, LayoutPathTraversal } from "./layout/types.ts";
 import { type PhysicsUpdate, type Physics } from "./layout/constants.ts";
+/**
+ * An interface which models the fields of `PointerEvent` that
+ * `<regular-layour>` actually uses, making it easier to sub out with an
+ * JavaScript object lieral when you don't have a `PointerEvent` handy.
+ */
+export interface PointerEventCoordinates {
+    clientX: number;
+    clientY: number;
+}
 /**
  * A Web Component that provides a resizable panel layout system.
  * Panels are arranged using CSS Grid and can be resized by dragging dividers.
@@ -32,6 +41,22 @@ import { type PhysicsUpdate, type Physics } from "./layout/constants.ts";
  * layout.restore(state);
  * ```
  *
+ * @remarks
+ *
+ * Why does this implementation use a `<slot>` at all? We must use
+ * `<slot>` and the Shadow DOM to scope the grid CSS rules to each
+ * instance of `<regular-layout>` (without e.g. giving them unique
+ * `"id"` and injecting into `document,head`), and we can only select
+ * `::slotted` light DOM children from `adoptedStyleSheets` on the
+ * `ShadowRoot`.
+ *
+ * Why does this implementation use a single `<slot>` and the child
+ * `"name"` attribute, as opposed to a named `<slot name="my_slot">`
+ * and the built-in `"slot"` child attribute? Children with a `"slot"`
+ * attribute don't fallback to the un-named `<slot>`, so using the
+ * latter implementation would require synchronizing the light DOM
+ * and shadow DOM slots/slotted children continuously.
+ *
  */
 export declare class RegularLayout extends HTMLElement {
     private _shadowRoot;
@@ -48,17 +73,24 @@ export declare class RegularLayout extends HTMLElement {
     /**
      * Determines which panel is at a given screen coordinate.
      *
-     * @param column - X coordinate in screen pixels.
-     * @param row - Y coordinate in screen pixels.
+     * @param coordinates - `PointerEvent`, `MouseEvent`, or just X and Y
+     *     coordinates in screen pixels.
      * @returns Panel information if a panel is at that position, null otherwise.
      */
-    calculateIntersect: (x: number, y: number, check_dividers?: boolean) => LayoutPath<Layout> | null;
+    calculateIntersect: (coordinates: PointerEventCoordinates) => LayoutPath | null;
+    /**
+     * Calculates the index path for a panel with the given name.
+     *
+     * @param name - The name of the panel to find.
+     * @returns The panel's index path if found, `null` otherwise.
+     */
+    calculatePath: (name: string) => number[] | null;
     /**
      * Sets the visual overlay state during drag-and-drop operations.
      * Displays a preview of where a panel would be placed at the given coordinates.
      *
-     * @param x - X coordinate in screen pixels.
-     * @param y - Y coordinate in screen pixels.
+     * @param event - `PointerEvent`, `MouseEvent`, or just X and Y
+     *     coordinates in screen pixels.
      * @param dragTarget - A `LayoutPath` (presumably from `calculateIntersect`)
      *     which points to the drag element in the current layout.
      * @param className - The CSS class name to use for the overlay panel
@@ -67,12 +99,12 @@ export declare class RegularLayout extends HTMLElement {
      *     the target, "absolute" positions the panel absolutely. Defaults to
      *     "absolute".
      */
-    setOverlayState: (x: number, y: number, { slot }: LayoutPath<unknown>, className?: string, mode?: OverlayMode) => void;
+    setOverlayState: (event: PointerEventCoordinates, { slot }: LayoutPath, className?: string, mode?: OverlayMode) => void;
     /**
      * Clears the overlay state and commits the panel placement.
      *
-     * @param x - X coordinate in screen pixels.
-     * @param y - Y coordinate in screen pixels.
+     * @param event - `PointerEvent`, `MouseEvent`, or just X and Y
+     *     coordinates in screen pixels.
      * @param dragTarget - A `LayoutPath` (presumably from `calculateIntersect`)
      *     which points to the drag element in the current layout.
      * @param className - The CSS class name to use for the overlay panel
@@ -80,7 +112,7 @@ export declare class RegularLayout extends HTMLElement {
      * @param mode - Overlay rendering mode that was used, must match the mode
      *     passed to `setOverlayState`. Defaults to "absolute".
      */
-    clearOverlayState: (x: number, y: number, drag_target: LayoutPath<Layout>, className?: string) => void;
+    clearOverlayState: (event: PointerEventCoordinates | null, { slot, layout }: LayoutPath, className?: string) => void;
     /**
      * Inserts a new panel into the layout at a specified path.
      *
@@ -92,7 +124,7 @@ export declare class RegularLayout extends HTMLElement {
      *     the new `SplitPanel` _if_ there is an option of orientation (e.g. if
      *     the layout had no pre-existing `SplitPanel`)
      */
-    insertPanel: (name: string, path?: number[], split?: boolean | Orientation) => void;
+    insertPanel: (name: string, path?: LayoutPathTraversal, split?: boolean | Orientation) => void;
     /**
      * Removes a panel from the layout by name.
      *
@@ -155,14 +187,26 @@ export declare class RegularLayout extends HTMLElement {
      * Transforms absolute pixel positions into normalized coordinates (0-1 range)
      * relative to the layout's bounding box.
      *
-     * @param clientX - X coordinate in screen pixels (client space).
-     * @param clientY - Y coordinate in screen pixels (client space).
+     * @param coordinates - `PointerEvent`, `MouseEvent`, or just X and Y
+     *     coordinates in screen pixels.
      * @returns A tuple containing:
      *   - col: Normalized X coordinate (0 = left edge, 1 = right edge)
      *   - row: Normalized Y coordinate (0 = top edge, 1 = bottom edge)
      *   - box: The layout element's bounding rectangle
      */
-    relativeCoordinates: (clientX: number, clientY: number, recalculate_bounds?: boolean) => [number, number, DOMRect, CSSStyleDeclaration];
+    relativeCoordinates: (event: PointerEventCoordinates, recalculate_bounds?: boolean) => [number, number, DOMRect, CSSStyleDeclaration];
+    /**
+     * Calculates the Euclidean distance in pixels between the current pointer
+     * coordinates and a drag target's position within the layout.
+     *
+     * @param coordinates - The current pointer event coordinates.
+     * @param drag_target - The layout path representing the drag target
+     * 	   position.
+     * @returns The distance in pixels between the coordinates and the drag
+     *     target.
+     */
+    diffCoordinates: (event: PointerEventCoordinates, drag_target: LayoutPath) => number;
+    private onDblClick;
     private onPointerDown;
     private onPointerMove;
     private onPointerUp;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "regular-layout",
-	"version": "0.2.1",
+	"version": "0.3.0",
 	"description": "A regular CSS `grid` container",
 	"keywords": [],
 	"license": "Apache-2.0",
@@ -10,6 +10,7 @@
 	},
 	"browser": "dist/index.js",
 	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
 	"type": "module",
 	"files": [
 		"dist/**/*",
@@ -20,7 +21,8 @@
 		"build": "tsx build.ts",
 		"build:watch": "tsx build.ts --watch",
 		"clean": "rm -rf dist",
-		"test": "playwright test",
+		"test": "playwright test tests/integration tests/unit",
+		"test:perf": "playwright test --workers=1 ./benchmarks",
 		"example": "tsx serve.ts",
 		"deploy": "tsx deploy.ts",
 		"lint": "biome lint src tests",

package/src/layout/calculate_edge.ts

@@ -11,11 +11,17 @@
 
 import { DEFAULT_PHYSICS, type Physics } from "./constants";
 import { insert_child } from "./insert_child";
-import type { Layout, LayoutPath, Orientation, ViewWindow } from "./types";
+import type {
+	Layout,
+	LayoutPath,
+	LayoutPathTraversal,
+	Orientation,
+	ViewWindow,
+} from "./types";
 
 /**
  * Calculates an insertion point (which may involve splitting a single
- * `"child-panel"` into a new `"split-panel"`), based on the  cursor position.
+ * `"tab-layout"` into a new `"split-layout"`), based on the  cursor position.
  * *
  * @param col - The cursor column.
  * @param row - The cursor row.
@@ -23,7 +29,7 @@ import type { Layout, LayoutPath, Orientation, ViewWindow } from "./types";
  * @param slot - The slot identifier where the insert should occur
  * @param drop_target - The `LayoutPath` (from `calculateIntersect`) of the
  * panel to either insert next to, or split by.
- * @returns A new `LayoutPath` reflecting the updated (maybe) `"split-panel"`,
+ * @returns A new `LayoutPath` reflecting the updated (maybe) `"split-layout"`,
  * which is enough to draw the overlay.
  */
 export function calculate_edge(
@@ -87,7 +93,9 @@ export function calculate_edge(
 			(box?.height || 1) *
 			(drop_target.view_window.row_end - drop_target.view_window.row_start);
 
-		const use_column = col_distance * col_scale > row_distance * row_scale;
+		const use_column =
+			col_scale / 2 - col_distance * col_scale <
+			row_scale / 2 - row_distance * row_scale;
 
 		return insert_axis(
 			panel,
@@ -131,7 +139,7 @@ function insert_root_edge(
 	panel: Layout,
 	slot: string,
 	drop_target: LayoutPath,
-	path: number[],
+	path: LayoutPathTraversal,
 	is_before: boolean,
 	orientation: Orientation,
 ): LayoutPath {
@@ -151,7 +159,7 @@ function insert_axis(
 	is_before: boolean,
 	axis_orientation: Orientation,
 ): LayoutPath {
-	let result_path: number[];
+	let result_path: LayoutPathTraversal;
 
 	if (drop_target.orientation === axis_orientation) {
 		// Same orientation - insert into existing split
@@ -181,7 +189,10 @@ function insert_axis(
 	};
 }
 
-function calculate_view_window(panel: Layout, path: number[]): ViewWindow {
+function calculate_view_window(
+	panel: Layout,
+	path: LayoutPathTraversal,
+): ViewWindow {
 	let view_window: ViewWindow = {
 		row_start: 0,
 		row_end: 1,
@@ -191,7 +202,7 @@ function calculate_view_window(panel: Layout, path: number[]): ViewWindow {
 
 	let current_panel = panel;
 	for (const step of path) {
-		if (current_panel.type === "child-panel") {
+		if (current_panel.type === "tab-layout") {
 			break;
 		}
 

package/src/layout/calculate_intersect.ts

@@ -9,7 +9,13 @@
 // ┃  *  [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). *  ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-import type { LayoutPath, LayoutDivider, Layout, ViewWindow } from "./types.ts";
+import type {
+	LayoutPath,
+	LayoutDivider,
+	Layout,
+	ViewWindow,
+	LayoutPathTraversal,
+} from "./types.ts";
 
 const VIEW_WINDOW = {
 	row_start: 0,
@@ -67,21 +73,21 @@ function calculate_intersection_recursive(
 	check_dividers: { rect: DOMRect; size: number } | null,
 	parent_orientation: "horizontal" | "vertical" | null = null,
 	view_window: ViewWindow = structuredClone(VIEW_WINDOW),
-	path: number[] = [],
+	path: LayoutPathTraversal = [],
 ): LayoutPath | null | LayoutDivider {
 	if (column < 0 || row < 0 || column > 1 || row > 1) {
 		return null;
 	}
 
 	// Base case: if this is a child panel, return its name
-	if (panel.type === "child-panel") {
+	if (panel.type === "tab-layout") {
 		const selected = panel.selected ?? 0;
 		const col_width = view_window.col_end - view_window.col_start;
 		const row_height = view_window.row_end - view_window.row_start;
 		return {
 			type: "layout-path",
-			layout: undefined,
-			slot: panel.child[selected],
+			layout: panel,
+			slot: panel.tabs[selected],
 			path,
 			view_window,
 			is_edge: false,

package/src/layout/calculate_path.ts

@@ -0,0 +1,53 @@
+// ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+// ░░░░░░░░▄▀░█▀▄░█▀▀░█▀▀░█░█░█░░░█▀█░█▀▄░░░░░█░░░█▀█░█░█░█▀█░█░█░▀█▀░▀▄░░░░░░░░
+// ░░░░░░░▀▄░░█▀▄░█▀▀░█░█░█░█░█░░░█▀█░█▀▄░▀▀▀░█░░░█▀█░░█░░█░█░█░█░░█░░░▄▀░░░░░░░
+// ░░░░░░░░░▀░▀░▀░▀▀▀░▀▀▀░▀▀▀░▀▀▀░▀░▀░▀░▀░░░░░▀▀▀░▀░▀░░▀░░▀▀▀░▀▀▀░░▀░░▀░░░░░░░░░
+// ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃  *  Copyright (c) 2026, the Regular Layout Authors. This file is part  *  ┃
+// ┃  *  of the Regular Layout library, distributed under the terms of the  *  ┃
+// ┃  *  [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). *  ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+import type { Layout, LayoutPathTraversal } from "./types.ts";
+
+/**
+ * Calculates the index path for a panel with the given name.
+ *
+ * Traverses the layout tree to find the named panel and returns the
+ * index path describing its position in the tree.
+ *
+ * @param name - The name of the panel to find.
+ * @param layout - The layout tree to search.
+ * @returns The panel's index path if found, `null` otherwise.
+ */
+export function calculate_path(name: string, layout: Layout): number[] | null {
+	return calculate_path_recursive(name, layout, []);
+}
+
+function calculate_path_recursive(
+	name: string,
+	panel: Layout,
+	path: LayoutPathTraversal,
+): number[] | null {
+	if (panel.type === "tab-layout") {
+		if (!panel.tabs.includes(name)) {
+			return null;
+		}
+
+		return path;
+	}
+
+	for (let i = 0; i < panel.children.length; i++) {
+		const result = calculate_path_recursive(name, panel.children[i], [
+			...path,
+			i,
+		]);
+
+		if (result) {
+			return result;
+		}
+	}
+
+	return null;
+}

package/src/layout/flatten.ts

@@ -23,7 +23,7 @@ import type { Layout } from "./types.ts";
  * @returns A new flattened layout tree (original is not mutated).
  */
 export function flatten(layout: Layout): Layout {
-	if (layout.type === "child-panel") {
+	if (layout.type === "tab-layout") {
 		layout.selected = layout.selected || 0;
 		return layout;
 	}
@@ -36,7 +36,7 @@ export function flatten(layout: Layout): Layout {
 		const flattenedChild = flatten(child);
 
 		if (
-			flattenedChild.type === "split-panel" &&
+			flattenedChild.type === "split-layout" &&
 			flattenedChild.orientation === layout.orientation
 		) {
 			for (let j = 0; j < flattenedChild.children.length; j++) {
@@ -54,7 +54,7 @@ export function flatten(layout: Layout): Layout {
 	}
 
 	return {
-		type: "split-panel",
+		type: "split-layout",
 		orientation: layout.orientation,
 		children: flattenedChildren,
 		sizes: flattenedSizes,

package/src/layout/generate_grid.ts

@@ -44,7 +44,7 @@ function collect_track_positions(
 	end: number,
 	physics: Physics,
 ): number[] {
-	if (panel.type === "child-panel") {
+	if (panel.type === "tab-layout") {
 		return [start, end];
 	}
 
@@ -100,11 +100,11 @@ function build_cells(
 	rowEnd: number,
 	physics: Physics,
 ): GridCell[] {
-	if (panel.type === "child-panel") {
+	if (panel.type === "tab-layout") {
 		const selected = panel.selected ?? 0;
 		return [
 			{
-				child: panel.child[selected],
+				child: panel.tabs[selected],
 				colStart: find_track_index(physics, colPositions, colStart),
 				colEnd: find_track_index(physics, colPositions, colEnd),
 				rowStart: find_track_index(physics, rowPositions, rowStart),
@@ -179,11 +179,11 @@ const child_template = (
  * @example
  * ```typescript
  * const layout = {
- *   type: "split-panel",
+ *   type: "split-layout",
  *   orientation: "horizontal",
  *   children: [
- *     { type: "child-panel", child: "sidebar" },
- *     { type: "child-panel", child: "main" }
+ *     { type: "tab-layout", tabs: "sidebar" },
+ *     { type: "tab-layout", tabs: "main" }
  *   ],
  *   sizes: [0.25, 0.75]
  * };
@@ -200,11 +200,11 @@ export function create_css_grid_layout(
 	overlay?: [string, string],
 	physics: Physics = DEFAULT_PHYSICS,
 ): string {
-	if (layout.type === "child-panel") {
+	if (layout.type === "tab-layout") {
 		const selected = layout.selected ?? 0;
 		return [
 			host_template("100%", "100%"),
-			child_template(physics, layout.child[selected], "1", "1"),
+			child_template(physics, layout.tabs[selected], "1", "1"),
 		].join("\n");
 	}
 

package/src/layout/generate_overlay.ts

@@ -16,7 +16,7 @@ export function updateOverlaySheet(
 	slot: string,
 	box: DOMRect,
 	style: CSSStyleDeclaration,
-	drag_target: LayoutPath<undefined> | null,
+	drag_target: LayoutPath | null,
 	physics = DEFAULT_PHYSICS,
 ) {
 	if (!drag_target) {