Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

feat(outliner): sibling sort modes + drag-between reorder

esenginea65408b640e4
diff --git a/desktop/src/engine/SceneCommands.ts b/desktop/src/engine/SceneCommands.ts
index ba6bf1f9d..236fd8894 100644
--- a/desktop/src/engine/SceneCommands.ts
+++ b/desktop/src/engine/SceneCommands.ts
@@ -554,6 +554,44 @@ export class SceneCommandsImpl {
this.history.record(records.length > 1 ? `Move ${records.length} to Folder` : 'Move to Folder', apply, revert);
}
+ /**
+ * Drag-reorder: move an entity to sit immediately before/after a sibling target.
+ * Aligns the dragged entity's parent + folder to the target's first (so it
+ * becomes a true sibling), then reorders scene order. One undo step; rejects
+ * dropping onto its own descendant (cycle) and no-op drops.
+ */
+ reorderEntity(sourceId: EntityId, targetId: EntityId, before: boolean): void {
+ if (sourceId === targetId) return;
+ const src = this.model.entityBySource(sourceId);
+ const tgt = this.model.entityBySource(targetId);
+ if (!src || !tgt) return;
+ if (this.isModelAncestor(targetId, sourceId)) return; // target is under source → cycle
+
+ const targetParent = tgt.parent ?? null;
+ const targetFolder = targetParent === null ? this.model.folderOf(targetId) : '';
+ const beforeOrder = this.model.entityOrder();
+ const beforeParent = src.parent ?? null;
+ const beforeFolder = this.model.folderOf(sourceId);
+
+ const apply = (): void => {
+ if ((this.model.entityBySource(sourceId)?.parent ?? null) !== targetParent) this.model.setParent(sourceId, targetParent);
+ if (targetParent === null) this.model.setFolder(sourceId, targetFolder);
+ this.model.moveEntityAdjacent(sourceId, targetId, before);
+ };
+ apply();
+
+ const afterOrder = this.model.entityOrder();
+ const orderSame = beforeOrder.length === afterOrder.length && beforeOrder.every((id, i) => id === afterOrder[i]);
+ const folderSame = targetParent !== null || beforeFolder === targetFolder;
+ if (orderSame && beforeParent === targetParent && folderSame) return; // dropped in place
+
+ this.history.record('Reorder', apply, () => {
+ this.model.setEntityOrder(beforeOrder);
+ this.model.setFolder(sourceId, beforeFolder);
+ this.model.setParent(sourceId, beforeParent);
+ });
+ }
+
/** Add a component (with its registered/schema defaults) to an entity. Undoable. */
// Apply an add to the model and return its undo op, or null if it's a no-op
// (entity gone / component already present). Shared by the single + batch paths.
diff --git a/desktop/src/engine/SceneModel.ts b/desktop/src/engine/SceneModel.ts
index cd2752fc5..7175c7f79 100644
--- a/desktop/src/engine/SceneModel.ts
+++ b/desktop/src/engine/SceneModel.ts
@@ -29,7 +29,9 @@ export type ModelEvent =
// folds it into the render projection; it never touches component data.
| { kind: 'hiddenChanged'; sourceId: number }
// An entity's editor lock changed — pure editor state (picking/selection only).
- | { kind: 'lockChanged'; sourceId: number };
+ | { kind: 'lockChanged'; sourceId: number }
+ // Scene entity order changed (sibling drag-reorder) — affects render order only.
+ | { kind: 'orderChanged' };
type Listener = (ev: ModelEvent) => void;
@@ -335,6 +337,42 @@ export class SceneModelImpl {
this.emit({ kind: 'lockChanged', sourceId });
}
+ // ── Sibling order (outliner drag-reorder; render order = `data.entities` order) ──
+ // The outliner derives sibling order from each entity's position in
+ // `data.entities` (buildSceneTree's parent index preserves it), so reordering is
+ // reordering this array. The World is order-agnostic (ECS), so these never reach
+ // the Reconciler.
+
+ /** The scene's entity ids in current (render) order. */
+ entityOrder(): number[] {
+ return this.data ? this.data.entities.map((e) => e.id) : [];
+ }
+
+ /** Reorder `data.entities` to match `ids` (ids absent from the list keep their tail order). */
+ setEntityOrder(ids: number[]): void {
+ if (!this.data) return;
+ const rank = new Map(ids.map((id, i) => [id, i]));
+ this.data.entities.sort((a, b) => (rank.get(a.id) ?? Infinity) - (rank.get(b.id) ?? Infinity));
+ this.emit({ kind: 'orderChanged' });
+ }
+
+ /** Move an entity immediately before/after a target in scene order (drag-reorder). */
+ moveEntityAdjacent(sourceId: number, targetId: number, before: boolean): void {
+ if (!this.data || sourceId === targetId) return;
+ const arr = this.data.entities;
+ const si = arr.findIndex((e) => e.id === sourceId);
+ if (si < 0) return;
+ const [moved] = arr.splice(si, 1);
+ let ti = arr.findIndex((e) => e.id === targetId);
+ if (ti < 0) {
+ arr.splice(si, 0, moved); // target vanished — put it back
+ return;
+ }
+ if (!before) ti += 1;
+ arr.splice(ti, 0, moved);
+ this.emit({ kind: 'orderChanged' });
+ }
+
// ── Source↔runtime map (Reconciler-only writers) ─────────────────────────
/** Bind a source id to its current runtime entity (Reconciler, on spawn). */
diff --git a/desktop/src/outliner/OutlinerController.ts b/desktop/src/outliner/OutlinerController.ts
index 1fa5b2d0f..9f7f9b266 100644
--- a/desktop/src/outliner/OutlinerController.ts
+++ b/desktop/src/outliner/OutlinerController.ts
@@ -17,7 +17,7 @@
import { create } from 'zustand';
import { SceneModel, SceneModelImpl } from '@/engine/SceneModel';
import type { EntityId } from '@/types';
-import { entityKey, folderKey } from './OutlinerModel';
+import { entityKey, folderKey, type SortMode } from './OutlinerModel';
import { folderPrefixes, normalizeFolder, rebaseFolder } from './folders';
interface OutlinerState {
@@ -27,6 +27,8 @@ interface OutlinerState {
query: string;
/** Keyboard-focus row (item key) — drives ↑↓←→ navigation; null = none. */
cursor: string | null;
+ /** Sibling sort: `manual` (scene order) / `name` / `type`. View-only. */
+ sortMode: SortMode;
/** Flip one row's expansion (pass an item key). */
toggleExpanded: (key: string) => void;
@@ -41,6 +43,7 @@ interface OutlinerState {
setQuery: (query: string) => void;
/** Move the keyboard-focus row. */
setCursor: (key: string | null) => void;
+ setSortMode: (mode: SortMode) => void;
/** Prune a removed entity's key (self-heal on the model's `entityRemoved`). */
dropId: (id: EntityId) => void;
@@ -54,6 +57,7 @@ export function createOutlinerStore(model: SceneModelImpl) {
expanded: new Set<string>(),
query: '',
cursor: null,
+ sortMode: 'manual',
toggleExpanded: (key) =>
set((s) => {
@@ -101,6 +105,7 @@ export function createOutlinerStore(model: SceneModelImpl) {
}),
setQuery: (query) => set({ query }),
setCursor: (cursor) => set({ cursor }),
+ setSortMode: (sortMode) => set({ sortMode }),
dropId: (id) =>
set((s) => {
diff --git a/desktop/src/outliner/OutlinerModel.ts b/desktop/src/outliner/OutlinerModel.ts
index 85ef7cd45..c28e375ed 100644
--- a/desktop/src/outliner/OutlinerModel.ts
+++ b/desktop/src/outliner/OutlinerModel.ts
@@ -52,9 +52,14 @@ export const entityKey = (id: EntityId): string => `e${id}`;
/** Expansion/identity key for a folder row. */
export const folderKey = (path: string): string => `f:${path}`;
+/** Sibling sort: `manual` keeps scene (data) order; `name`/`type` are view-only. */
+export type SortMode = 'manual' | 'name' | 'type';
+
export interface BuildOutlinerOpts {
/** Expanded item keys. Ignored when `expandAll` (or a filter) is on. */
expanded: ReadonlySet<string>;
+ /** Sibling sort mode (default `manual` = scene order). */
+ sort?: SortMode;
/** A root entity's folder path (`""` = scene root). Absent ⇒ no folders (PIE). */
folderOf?: (id: EntityId) => string;
/** The scene's explicit (incl. empty) folders, so empties still show. */
@@ -94,6 +99,15 @@ export function parseQuery(raw: string): ParsedQuery {
const queryActive = (q: ParsedQuery): boolean => q.text !== '' || q.types.length > 0 || q.comps.length > 0;
+/** Sort a sibling list by mode (manual = unchanged scene order). */
+function sortNodes(nodes: SceneNode[], mode: SortMode): SceneNode[] {
+ if (mode === 'manual') return nodes;
+ const by = mode === 'name'
+ ? (a: SceneNode, b: SceneNode) => a.name.localeCompare(b.name)
+ : (a: SceneNode, b: SceneNode) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name);
+ return [...nodes].sort(by);
+}
+
/** Keep a node if it matches `keep`, or any descendant does (matches + ancestors). */
function filterNode(node: SceneNode, keep: (n: SceneNode) => boolean): SceneNode | null {
if (keep(node)) return node; // self matches → keep the whole subtree
@@ -124,6 +138,7 @@ export function buildOutlinerItems(data: SceneData | null, opts: BuildOutlinerOp
const shown = active ? roots.map((n) => filterNode(n, keep)).filter((n): n is SceneNode => n != null) : roots;
const expandAll = !!opts.expandAll || active;
const folderOf = opts.folderOf ?? (() => ROOT_FOLDER);
+ const sort = opts.sort ?? 'manual';
// Group the shown roots by their folder path, and gather every folder to show:
// each root path's prefixes, plus the scene's explicit folders (only when not
@@ -151,7 +166,7 @@ export function buildOutlinerItems(data: SceneData | null, opts: BuildOutlinerOp
const hasChildren = !!node.children?.length;
const expanded = expandAll || opts.expanded.has(entityKey(node.id));
out.push({ kind: 'entity', key: entityKey(node.id), id: node.id, node, depth, hasChildren, expanded, parentKey });
- if (hasChildren && expanded) for (const c of node.children!) emitEntity(c, depth + 1, entityKey(node.id));
+ if (hasChildren && expanded) for (const c of sortNodes(node.children!, sort)) emitEntity(c, depth + 1, entityKey(node.id));
};
// Emit the child folders of `path` (nested) then the entity roots directly in it.
@@ -162,7 +177,7 @@ export function buildOutlinerItems(data: SceneData | null, opts: BuildOutlinerOp
out.push({ kind: 'folder', key: folderKey(fp), path: fp, name: folderName(fp), count: countUnder(fp), depth, hasChildren: hasKids, expanded, parentKey });
if (expanded) emitFolderContents(fp, depth + 1, folderKey(fp));
}
- for (const root of rootsByFolder.get(path) ?? []) emitEntity(root, depth, parentKey);
+ for (const root of sortNodes(rootsByFolder.get(path) ?? [], sort)) emitEntity(root, depth, parentKey);
};
emitFolderContents(ROOT_FOLDER, 0, null);
diff --git a/desktop/src/outliner/OutlinerRow.tsx b/desktop/src/outliner/OutlinerRow.tsx
index bf5efc4f1..650fb831b 100644
--- a/desktop/src/outliner/OutlinerRow.tsx
+++ b/desktop/src/outliner/OutlinerRow.tsx
@@ -52,7 +52,8 @@ export interface OutlinerRowProps {
/** Lowercased substring to highlight in the name (the search bare text). */
highlight?: string;
renaming?: boolean;
- isDrop?: boolean;
+ /** Active drop indicator: `on` (full row) or a between-rows insertion line. */
+ dropPos?: 'before' | 'on' | 'after';
/** Prefab-instance member — warm icon tint (entity rows only). */
prefab?: boolean;
/** When false, the twist is hidden + non-interactive (the always-expanded PIE tree). */
@@ -71,7 +72,7 @@ export interface OutlinerRowProps {
}
export function OutlinerRow(props: OutlinerRowProps) {
- const { item, selected, renaming, isDrop, prefab } = props;
+ const { item, selected, renaming, dropPos, prefab } = props;
const isFolder = item.kind === 'folder';
const { depth, hasChildren, expanded } = item;
@@ -107,7 +108,9 @@ export function OutlinerRow(props: OutlinerRowProps) {
`${locked ? ' locked' : ''}` +
`${prefab ? ' prefab' : ''}` +
`${isFolder ? ' folder' : ''}` +
- `${isDrop ? ' drop' : ''}`
+ `${dropPos === 'on' ? ' drop' : ''}` +
+ `${dropPos === 'before' ? ' drop-before' : ''}` +
+ `${dropPos === 'after' ? ' drop-after' : ''}`
}
style={{ paddingLeft: depth * 14 }}
draggable={props.draggable && !renaming}
diff --git a/desktop/src/panels/Outliner.tsx b/desktop/src/panels/Outliner.tsx
index 29bc4526e..2dfd3646a 100644
--- a/desktop/src/panels/Outliner.tsx
+++ b/desktop/src/panels/Outliner.tsx
@@ -1,7 +1,7 @@
// SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0
// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
-import { Search, Plus, FolderPlus } from 'lucide-react';
+import { Search, Plus, FolderPlus, ArrowDownUp } from 'lucide-react';
import { useEditorStore } from '@/store/editorStore';
import { useSelection } from '@/store/selectionStore';
import { EngineHost } from '@/engine/EngineHost';
@@ -70,6 +70,7 @@ export function Outliner() {
const setQuery = useOutliner((s) => s.setQuery);
const toggleExpanded = useOutliner((s) => s.toggleExpanded);
const cursor = useOutliner((s) => s.cursor);
+ const sortMode = useOutliner((s) => s.sortMode);
const selectedIds = useSelection((s) => s.selectedIds);
const selectedId = useSelection((s) => s.selectedId);
const isPlaying = useEditorStore((s) => s.isPlaying);
@@ -79,8 +80,9 @@ export function Outliner() {
const dragIds = useRef<EntityId[] | null>(null);
const [renaming, setRenaming] = useState<string | null>(null); // item key
- const [dropId, setDropId] = useState<string | null>(null); // item key
+ const [drop, setDrop] = useState<{ key: string; pos: 'before' | 'on' | 'after' } | null>(null);
const [ctx, setCtx] = useState<{ x: number; y: number; item: OutlinerItem } | null>(null);
+ const [sortMenu, setSortMenu] = useState<{ x: number; y: number } | null>(null);
// Controlled scroll for reveal-on-select + keyboard nav (nonce re-fires same index).
const [scrollTo, setScrollTo] = useState<{ index: number; nonce: number }>({ index: -1, nonce: 0 });
const scrollNonce = useRef(0);
@@ -96,11 +98,12 @@ export function Outliner() {
? buildOutlinerItems(SceneModel.current, {
expanded,
query,
+ sort: sortMode,
folderOf: (id) => SceneModel.folderOf(id),
folders: SceneModel.sceneFolders(),
})
: [],
- [engine.status, structRev, expanded, query],
+ [engine.status, structRev, expanded, query, sortMode],
);
const flatIds = useMemo(() => entityIds(items), [items]);
const highlight = useMemo(() => parseQuery(query).text, [query]);
@@ -289,32 +292,52 @@ export function Outliner() {
else if (isAssetDrag(e)) e.dataTransfer.dropEffect = 'copy';
else return;
e.preventDefault();
- if (dropId !== item.key) setDropId(item.key);
+ // Hovering the top/bottom quarter of an entity row (manual sort, entity drag)
+ // is a between-rows reorder; the middle is a reparent. Folders are always 'on'.
+ let pos: 'before' | 'on' | 'after' = 'on';
+ if (dragIds.current && item.kind === 'entity' && sortMode === 'manual') {
+ const rect = e.currentTarget.getBoundingClientRect();
+ const rel = (e.clientY - rect.top) / rect.height;
+ pos = rel < 0.25 ? 'before' : rel > 0.75 ? 'after' : 'on';
+ }
+ if (drop?.key !== item.key || drop?.pos !== pos) setDrop({ key: item.key, pos });
};
const reparent = (target: EntityId | null) => {
const ids = dragIds.current;
dragIds.current = null;
- setDropId(null);
+ setDrop(null);
if (!ids) return;
for (const child of ids) if (child !== target) SceneCommands.setParent(child, target);
};
const moveToFolder = (path: string | null) => {
const ids = dragIds.current;
dragIds.current = null;
- setDropId(null);
+ setDrop(null);
if (ids) SceneCommands.moveToFolder(ids, path);
};
const onDropRow = (item: OutlinerItem, e: React.DragEvent) => {
e.preventDefault();
e.stopPropagation();
- setDropId(null);
+ const pos = drop?.pos ?? 'on';
+ setDrop(null);
if (item.kind === 'folder') {
if (dropPrefabAsset(e, null)) return; // prefab onto a folder → instantiate at root
moveToFolder(item.path);
return;
}
if (dropPrefabAsset(e, item.id)) return; // prefab onto an entity = under it
- reparent(item.id);
+ if (pos === 'on') {
+ reparent(item.id);
+ return;
+ }
+ // Drop-between → reorder as a sibling of the target ('after' reversed so a
+ // multi-drag keeps its relative order).
+ const ids = dragIds.current;
+ dragIds.current = null;
+ if (ids) {
+ const ordered = pos === 'before' ? ids : [...ids].reverse();
+ for (const id of ordered) if (id !== item.id) SceneCommands.reorderEntity(id, item.id, pos === 'before');
+ }
};
// Empty-space drop = move to the scene root (un-parent + clear folder).
@@ -384,7 +407,7 @@ export function Outliner() {
cursored={cursor === it.key}
highlight={highlight}
renaming={renaming === it.key}
- isDrop={dropId === it.key}
+ dropPos={drop?.key === it.key ? drop.pos : undefined}
prefab={it.kind === 'entity' && SceneModel.prefabTag(it.id) != null}
draggable={it.kind === 'entity'}
onToggle={toggleExpanded}
@@ -426,6 +449,17 @@ export function Outliner() {
onChange={(e) => setQuery(e.target.value)}
/>
</div>
+ <button
+ type="button"
+ className={`pbtn${sortMode !== 'manual' ? ' on' : ''}`}
+ title={`Sort: ${sortMode}`}
+ onClick={(e) => {
+ const r = e.currentTarget.getBoundingClientRect();
+ setSortMenu({ x: r.left, y: r.bottom + 2 });
+ }}
+ >
+ <ArrowDownUp size={14} strokeWidth={2} />
+ </button>
<button type="button" className="pbtn" title="New folder" onClick={() => newFolder('', null)}>
<FolderPlus size={15} strokeWidth={2} />
</button>
@@ -473,6 +507,17 @@ export function Outliner() {
)}
{ctx && !gameMode && <ContextMenu x={ctx.x} y={ctx.y} items={ctxItems} onClose={() => setCtx(null)} />}
+ {sortMenu && !gameMode && (
+ <ContextMenu
+ x={sortMenu.x}
+ y={sortMenu.y}
+ onClose={() => setSortMenu(null)}
+ items={(['manual', 'name', 'type'] as const).map((m) => ({
+ label: `Sort: ${m[0].toUpperCase()}${m.slice(1)}`,
+ onClick: () => useOutliner.getState().setSortMode(m),
+ }))}
+ />
+ )}
</div>
);
}
diff --git a/desktop/src/theme/outliner.css b/desktop/src/theme/outliner.css
index 5f3573903..451fb17cb 100644
--- a/desktop/src/theme/outliner.css
+++ b/desktop/src/theme/outliner.css
@@ -26,6 +26,7 @@
transition: color var(--t-fast), background var(--t-fast);
}
.pbtn:hover { color: var(--text); background: var(--srf-4); }
+.pbtn.on { color: var(--acc); }
.pbody { flex: 1; min-height: 0; overflow-y: auto; overflow-x: hidden; }
/* Column header strip */
@@ -62,6 +63,9 @@
.row.sel { background: var(--acc); color: #fff; }
.row.sel:hover { background: var(--acc); }
.row.drop { background: var(--acc-soft); box-shadow: inset 0 0 0 1px var(--acc); }
+/* Between-rows reorder insertion line (top = before, bottom = after). */
+.row.drop-before { box-shadow: inset 0 2px 0 0 var(--acc); }
+.row.drop-after { box-shadow: inset 0 -2px 0 0 var(--acc); }
/* Keyboard-focus ring (distinct from selection; mainly visible on folder rows). */
.row.cursor:not(.sel) { box-shadow: inset 0 0 0 1px var(--acc-soft); }
.pbody:focus, .pbody:focus-visible { outline: none; }
diff --git a/desktop/tests/outliner-model.test.ts b/desktop/tests/outliner-model.test.ts
index 3ccdaf5f4..c98e39381 100644
--- a/desktop/tests/outliner-model.test.ts
+++ b/desktop/tests/outliner-model.test.ts
@@ -160,3 +160,30 @@ describe('token search', () => {
expect(queryIds(compScene(), 'type:sprite zzz')).toEqual([]); // name fails → none
});
});
+
+// kinds: 2=camera, 1/3/4=sprite. names chosen so name-sort ≠ type-sort.
+function sortScene(): SceneData {
+ return {
+ version: '1.0',
+ name: 's',
+ entities: [
+ { id: 1, name: 'Zed', parent: null, children: [], components: [{ type: 'Sprite', data: {} }] },
+ { id: 2, name: 'Apple', parent: null, children: [], components: [{ type: 'Camera', data: {} }] },
+ { id: 3, name: 'Mid', parent: null, children: [], components: [{ type: 'Sprite', data: {} }] },
+ { id: 4, name: 'Aaa', parent: null, children: [], components: [{ type: 'Sprite', data: {} }] },
+ ],
+ } as unknown as SceneData;
+}
+
+describe('sort mode', () => {
+ const sortedKeys = (sort: 'manual' | 'name' | 'type') => keys(buildOutlinerItems(sortScene(), { expanded: new Set(), sort }));
+ it('manual keeps scene (data) order', () => {
+ expect(sortedKeys('manual')).toEqual(['e1', 'e2', 'e3', 'e4']);
+ });
+ it('name sorts alphabetically', () => {
+ expect(sortedKeys('name')).toEqual(['e4', 'e2', 'e3', 'e1']); // Aaa, Apple, Mid, Zed
+ });
+ it('type sorts by kind then name', () => {
+ expect(sortedKeys('type')).toEqual(['e2', 'e4', 'e3', 'e1']); // camera(Apple), then sprites Aaa, Mid, Zed
+ });
+});
diff --git a/desktop/tests/outliner-reorder.test.ts b/desktop/tests/outliner-reorder.test.ts
new file mode 100644
index 000000000..625a64fe0
--- /dev/null
+++ b/desktop/tests/outliner-reorder.test.ts
@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0
+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
+/**
+ * @file Outliner sibling drag-reorder (REARCH_OUTLINER P4). Render order derives
+ * from `data.entities` order; reorderEntity aligns parent+folder to the
+ * target then moves the entity adjacent, undoable. Model+command only.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import type { SceneData } from 'esengine';
+import { EditorSession } from '@/engine/EditorSession';
+
+const ent = (id: number, parent: number | null, children: number[]) => ({ id, name: `E${id}`, parent, children, components: [] as unknown[] });
+const flat = (): SceneData => ({ version: '1.0', name: 'o', entities: [ent(1, null, []), ent(2, null, []), ent(3, null, [])] }) as unknown as SceneData;
+
+describe('SceneCommands.reorderEntity', () => {
+ let S: EditorSession;
+ beforeEach(() => {
+ S = EditorSession.create();
+ S.model.adopt(flat(), new Map());
+ });
+
+ it('moves a sibling before a target; undo restores scene order', () => {
+ expect(S.model.entityOrder()).toEqual([1, 2, 3]);
+ S.commands.reorderEntity(3, 1, true); // drop 3 before 1
+ expect(S.model.entityOrder()).toEqual([3, 1, 2]);
+ S.history.undo();
+ expect(S.model.entityOrder()).toEqual([1, 2, 3]);
+ });
+
+ it('moves a sibling after a target', () => {
+ S.commands.reorderEntity(1, 3, false); // drop 1 after 3
+ expect(S.model.entityOrder()).toEqual([2, 3, 1]);
+ });
+
+ it('aligns the dragged entity folder to the target (root drop)', () => {
+ S.model.setFolder(1, 'A/B');
+ S.commands.reorderEntity(2, 1, true); // 2 before 1 → inherits folder A/B
+ expect(S.model.folderOf(2)).toBe('A/B');
+ expect(S.model.entityOrder()).toEqual([2, 1, 3]);
+ S.history.undo();
+ expect(S.model.folderOf(2)).toBe('');
+ expect(S.model.entityOrder()).toEqual([1, 2, 3]);
+ });
+
+ it('rejects dropping onto its own descendant (cycle)', () => {
+ S.model.adopt({ version: '1.0', name: 'o', entities: [ent(1, null, [2]), ent(2, 1, [])] } as unknown as SceneData, new Map());
+ S.commands.reorderEntity(1, 2, true); // 1 is 2's ancestor → rejected, order unchanged
+ expect(S.model.entityOrder()).toEqual([1, 2]);
+ });
+
+ it('a drop in place records nothing (no undo step)', () => {
+ const before = S.history.canUndo();
+ S.commands.reorderEntity(2, 2, true); // onto self → no-op
+ expect(S.history.canUndo()).toBe(before);
+ });
+});