react-native-layout-dnd 0.1.0-alpha.0

package/lib/module/controller/dndSession.js

@@ -0,0 +1,621 @@
+"use strict";
+
+import { samePlacement } from "../engine/gridPlacements.js";
+import { computeValidatedLayoutMove } from "../engine/layoutMove.js";
+import { validateLayoutState } from "../engine/layoutState.js";
+import { isCellSpan, isPositiveInteger, isRecord } from "../engine/validation.js";
+import { DEFAULT_SEARCH_BUDGET } from "../defaults.js";
+import { resolveGridMovementPolicy, validateGridMovementPolicy } from "../engine/movementPolicy.js";
+import { respondToValidatedDndProposal } from "./dndState.js";
+import { now, reportCallbackError as reportFailure } from "./coordinatorBase.js";
+import { layoutLocation, sameLayoutLocation } from "./locations.js";
+import { PreviewPath } from "./previewPath.js";
+import { SessionCore, validatedDecision } from "./sessionCore.js";
+let instanceCounter = 0;
+
+/** Capture structure by value so an in-place same-revision edit still invalidates a drag. */
+function layoutKey(value) {
+  return JSON.stringify([value.revision, value.items.map(item => item.id).sort(), value.zones.map(zone => zone.kind === 'list' ? [zone.id, zone.kind, zone.orientation, [...zone.itemIds]] : [zone.id, zone.kind, zone.rows, zone.columns, zone.placements.map(item => [item.itemId, item.position.row, item.position.col, item.span.rows, item.span.cols, item.placement]).sort((a, b) => String(a[0]).localeCompare(String(b[0])))]).sort((a, b) => String(a[0]).localeCompare(String(b[0])))]);
+}
+function sameTarget(first, second) {
+  if (!first || !second) return first === second;
+  if (first.zoneId !== second.zoneId) return false;
+  return first.kind === 'list' && second.kind === 'list' ? first.index === second.index : first.kind === 'grid' && second.kind === 'grid' && first.position?.row === second.position?.row && first.position?.col === second.position?.col;
+}
+/** Compare generated layout containers without reading or copying opaque data. */
+function samePreviewStructure(first, second, structure) {
+  if (Object.is(first, second)) return true;
+  if (first === null || second === null || typeof first !== 'object' || typeof second !== 'object' || Object.getPrototypeOf(first) !== Object.getPrototypeOf(second)) return false;
+  const keys = Reflect.ownKeys(first);
+  const otherKeys = Reflect.ownKeys(second);
+  return keys.length === otherKeys.length && keys.every((key, index) => {
+    if (key !== otherKeys[index]) return false;
+    const a = Object.getOwnPropertyDescriptor(first, key);
+    const b = Object.getOwnPropertyDescriptor(second, key);
+    if (!('value' in a) || !('value' in b) || a.enumerable !== b.enumerable) return false;
+    let child;
+    if (structure === 'state' && key === 'zones') child = 'zones';else if (structure === 'zone' && key === 'itemIds') child = 'itemIds';else if (structure === 'zone' && key === 'placements') child = 'placements';else if (structure === 'placement' && (key === 'position' || key === 'span') || structure === 'target' && key === 'position') child = 'coordinates';else if ((structure === 'zones' || structure === 'placements') && typeof key === 'string' && /^(0|[1-9]\d*)$/.test(key)) child = structure === 'zones' ? 'zone' : 'placement';
+    // Item arrays and extra metadata retain their exact identity. In
+    // particular, equality never traverses caller-owned item.data objects.
+    return child ? samePreviewStructure(a.value, b.value, child) : Object.is(a.value, b.value);
+  });
+}
+function sameVisibleSnapshot(first, second) {
+  return Object.keys(first).every(key => key === 'seq' || (key === 'candidate' || key === 'displayValue' ? samePreviewStructure(first[key], second[key], 'state') : key === 'target' ? samePreviewStructure(first[key], second[key], 'target') : Object.is(first[key], second[key])));
+}
+function settingsKey(options) {
+  return JSON.stringify([options.searchBudget ?? DEFAULT_SEARCH_BUDGET, options.responseTimeoutMs ?? 2000, resolveGridMovementPolicy(options.movementPolicy)]);
+}
+function copyMovementPolicy(policy) {
+  const resolved = resolveGridMovementPolicy(policy);
+  return Object.freeze({
+    ...resolved,
+    candidateOrder: Object.freeze([...resolved.candidateOrder]),
+    pointer: Object.freeze({
+      ...resolved.pointer
+    })
+  });
+}
+function copyGridItemLayout(value) {
+  if (!isRecord(value) || !isCellSpan(value.span) || value.placement !== undefined && value.placement !== 'insert' && value.placement !== 'exchange') return null;
+  return Object.freeze({
+    span: Object.freeze({
+      rows: value.span.rows,
+      cols: value.span.cols
+    }),
+    ...(value.placement === undefined ? {} : {
+      placement: value.placement
+    })
+  });
+}
+function checkOptions(options) {
+  const checked = validateLayoutState(options.value);
+  const issues = checked.valid ? [] : [...checked.issues];
+  const policy = validateGridMovementPolicy(options.movementPolicy);
+  if (!policy.valid) issues.push(...policy.issues);
+  const budgetValid = isPositiveInteger(options.searchBudget === undefined ? DEFAULT_SEARCH_BUDGET : options.searchBudget);
+  const timeoutValid = isPositiveInteger(options.responseTimeoutMs ?? 2000);
+  if (!budgetValid) issues.push({
+    code: 'invalid-budget',
+    message: 'searchBudget must be a positive safe integer.'
+  });
+  if (options.responseTimeoutMs !== undefined && !isPositiveInteger(options.responseTimeoutMs) || options.disabled !== undefined && typeof options.disabled !== 'boolean' || typeof options.onChange !== 'function' || ['canDrop', 'onDragStart', 'onDragEnd', 'onValidationError', 'getGridItemLayout'].some(key => {
+    const callback = options[key];
+    return callback !== undefined && typeof callback !== 'function';
+  })) {
+    issues.push({
+      code: 'invalid-configuration',
+      message: 'Session callbacks, disabled or response timeout are invalid.'
+    });
+  }
+  return {
+    layoutValid: checked.valid,
+    issues,
+    movementPolicy: copyMovementPolicy(policy.valid ? options.movementPolicy : undefined),
+    settingsKey: policy.valid && budgetValid && timeoutValid ? settingsKey(options) : null
+  };
+}
+function reportCallbackError(error) {
+  reportFailure('LayoutDnD', error);
+}
+
+/** Give a stored preview the item objects of a same-layout recommit. */
+function rebaseLayoutState(value, committed) {
+  return value.items === committed.items ? value : {
+    ...value,
+    items: committed.items
+  };
+}
+
+/** Compare zone layouts by ID; revision and caller items are not layout. */
+function sameLayoutZones(first, second) {
+  if (first.zones.length !== second.zones.length) return false;
+  const zones = new Map(second.zones.map(zone => [zone.id, zone]));
+  return first.zones.every(zone => {
+    const other = zones.get(zone.id);
+    if (!other) return false;
+    if (zone === other) return true;
+    if (zone.kind === 'list') return other.kind === 'list' && zone.itemIds.length === other.itemIds.length && zone.itemIds.every((id, index) => id === other.itemIds[index]);
+    if (other.kind !== 'grid' || zone.placements.length !== other.placements.length) return false;
+    const placements = new Map(other.placements.map(item => [item.itemId, item]));
+    return zone.placements.every(item => {
+      const match = placements.get(item.itemId);
+      return match !== undefined && samePlacement(item, match);
+    });
+  });
+}
+
+/** Express a candidate built on an earlier preview relative to the committed value. */
+function relativeToCommitted(committed, from, result) {
+  if (sameLayoutZones(committed, result.value)) return {
+    ...result,
+    value: committed,
+    from,
+    changed: false
+  };
+  if (committed.revision === Number.MAX_SAFE_INTEGER) return {
+    status: 'invalid',
+    issues: [{
+      code: 'invalid-revision',
+      message: 'The layout revision cannot exceed a safe integer.'
+    }]
+  };
+  const revision = committed.revision + 1;
+  const value = result.value.revision === revision && result.value.items === committed.items ? result.value : {
+    ...result.value,
+    revision,
+    items: committed.items
+  };
+  return {
+    ...result,
+    value,
+    from,
+    changed: true
+  };
+}
+
+/** UI-independent normalized session; screen/scroll measurements stay in the adapter. */
+export class DndSessionCoordinator extends SessionCore {
+  instanceId = ++instanceCounter;
+  sessionCounter = 0;
+  validationNotification = null;
+  previewInputVersion = 0;
+  operationVersion = 0;
+  constructor(options) {
+    const checked = checkOptions(options);
+    const lastValidValue = checked.layoutValid ? options.value : null;
+    super({
+      value: lastValidValue,
+      displayValue: lastValidValue,
+      candidate: null,
+      phase: 'idle',
+      sessionId: null,
+      itemId: null,
+      sourceZoneId: null,
+      targetZoneId: null,
+      target: null,
+      seq: 0,
+      validity: checked.issues.length ? 'invalid' : 'valid',
+      disabled: checked.issues.length > 0 || options.disabled === true,
+      gridItemLayouts: new Map(),
+      movementPolicy: checked.movementPolicy,
+      failureReason: null
+    }, lastValidValue);
+    this.options = options;
+    this.lastLayoutKey = checked.layoutValid ? layoutKey(options.value) : null;
+  }
+
+  /** Every batch is one operation; a refresh may only fold into its own. */
+  batchStarted() {
+    this.operationVersion++;
+  }
+  diagnosticObserver() {
+    return typeof this.options.onDiagnostic === 'function' ? this.options.onDiagnostic : undefined;
+  }
+
+  /** Commit owner state after render; ordinary scroll updates do not enter this contract. */
+  commit(options) {
+    this.batch(() => {
+      this.disposed = false;
+      const previousValue = this.lastValidValue;
+      const checked = checkOptions(options);
+      const key = checked.layoutValid ? layoutKey(options.value) : null;
+      const layoutChanged = key !== this.lastLayoutKey;
+      if (options.value !== this.options.value || options.canDrop !== this.options.canDrop) this.previewInputVersion++;
+      this.options = options;
+      this.lastLayoutKey = key;
+      if (checked.layoutValid) this.lastValidValue = options.value;
+      const disabled = checked.issues.length > 0 || options.disabled === true;
+      this.update({
+        value: this.lastValidValue,
+        disabled
+      });
+      const session = this.session;
+      const settingsChanged = !!session && (checked.settingsKey !== session.settingsKey || options.getGridItemLayout !== session.getGridItemLayout);
+      if (!session) {
+        this.update({
+          displayValue: this.lastValidValue,
+          validity: disabled ? 'invalid' : 'valid',
+          ...(JSON.stringify(this.snapshot.movementPolicy) !== JSON.stringify(checked.movementPolicy) ? {
+            movementPolicy: checked.movementPolicy
+          } : {})
+        });
+      } else if (this.snapshot.phase === 'awaiting-response') {
+        const response = isRecord(options.value) ? options.value.proposalResponse : undefined;
+        const matches = isRecord(response) && response.sessionId === session.sessionId && response.baseRevision === session.baseRevision && typeof response.accepted === 'boolean';
+        if (session.deadline !== undefined && now() >= session.deadline) {
+          this.settle(session, 'expired');
+        } else if (settingsChanged) {
+          this.interrupt(session, 'input-changed');
+        } else if (matches) {
+          // Acceptance is judged by layout and revision (the layout key). The
+          // owner may rebuild item objects or data in the accepting commit,
+          // as a store that derives a dock item from a page item does.
+          this.settle(session, response.accepted === false ? 'rejected' : checked.layoutValid && key === session.proposalKey ? 'accepted' : 'mismatch');
+        } else if (layoutChanged) {
+          this.interrupt(session, key === session.proposalKey ? 'response-missing' : 'input-changed');
+        } else if (disabled) {
+          this.interrupt(session, 'disabled');
+        }
+      } else if (layoutChanged) {
+        this.cancelWith('input-changed');
+      } else if (disabled) {
+        this.cancelWith('disabled');
+      } else if (settingsChanged) {
+        this.cancelWith('input-changed');
+      } else if (this.snapshot.displayValue === previousValue) {
+        this.update({
+          displayValue: this.lastValidValue
+        });
+      }
+      const notification = checked.issues.length ? JSON.stringify(checked.issues) : null;
+      if (notification !== this.validationNotification) {
+        this.validationNotification = notification;
+        if (notification && typeof options.onValidationError === 'function') {
+          try {
+            options.onValidationError(checked.issues);
+          } catch (error) {
+            reportCallbackError(error);
+          }
+        }
+      }
+    });
+  }
+  start(itemId, baseRevision) {
+    return this.batch(() => {
+      if (this.disposed || this.session || this.snapshot.disabled || !this.lastValidValue || baseRevision !== undefined && baseRevision !== this.lastValidValue.revision) return null;
+      const checked = checkOptions(this.options);
+      if (checked.issues.length) {
+        this.commit(this.options);
+        return null;
+      }
+      const source = this.lastValidValue.zones.find(zone => zone.kind === 'list' ? zone.itemIds.includes(itemId) : zone.placements.some(item => item.itemId === itemId));
+      if (!source) return null;
+      const base = this.lastValidValue;
+      const gridSource = source.kind === 'grid' ? source.placements.find(item => item.itemId === itemId) : null;
+      const from = source.kind === 'list' ? {
+        kind: 'list',
+        zoneId: source.id,
+        index: source.itemIds.indexOf(itemId)
+      } : {
+        kind: 'grid',
+        zoneId: source.id,
+        position: {
+          ...gridSource.position
+        }
+      };
+      const session = {
+        sessionId: `layout-dnd:${this.instanceId}:${++this.sessionCounter}`,
+        itemId,
+        sourceZoneId: source.id,
+        baseRevision: this.lastValidValue.revision,
+        seq: -1,
+        target: null,
+        path: new PreviewPath(sameLayoutLocation, rebaseLayoutState),
+        gridItemLayouts: new Map(),
+        gridItemLayoutErrors: new Map(),
+        movementPolicy: checked.movementPolicy,
+        searchBudget: this.options.searchBudget ?? DEFAULT_SEARCH_BUDGET,
+        responseTimeoutMs: this.options.responseTimeoutMs ?? 2000,
+        settingsKey: settingsKey(this.options),
+        getGridItemLayout: this.options.getGridItemLayout,
+        resolving: true,
+        previewSeq: null,
+        previewInputVersion: this.previewInputVersion
+      };
+      this.session = session;
+      this.update({
+        phase: 'dragging',
+        sessionId: session.sessionId,
+        itemId,
+        sourceZoneId: source.id,
+        targetZoneId: null,
+        target: null,
+        candidate: null,
+        seq: -1,
+        displayValue: this.lastValidValue,
+        validity: 'pending',
+        failureReason: null,
+        gridItemLayouts: new Map(),
+        movementPolicy: session.movementPolicy
+      });
+      try {
+        const item = base.items.find(candidate => candidate.id === itemId);
+        for (const target of base.zones) {
+          if (target.kind !== 'grid') continue;
+          const descriptor = target.id === source.id ? gridSource : session.getGridItemLayout ? session.getGridItemLayout({
+            item,
+            from,
+            target,
+            value: base
+          }) : gridSource;
+          if (this.session !== session) return null;
+          const copied = copyGridItemLayout(descriptor);
+          if (copied) session.gridItemLayouts.set(target.id, copied);else session.gridItemLayoutErrors.set(target.id, descriptor === null || descriptor === undefined ? 'missing-grid-item-layout' : 'invalid-grid-item-layout');
+        }
+      } catch (error) {
+        if (this.session === session) this.cancelWith('policy-error', error);else reportCallbackError(error);
+        return null;
+      }
+      session.resolving = false;
+      this.update({
+        gridItemLayouts: new Map(session.gridItemLayouts)
+      });
+      try {
+        this.options.onDragStart?.(this.event(session));
+      } catch (error) {
+        if (this.session === session) this.cancelWith('start-handler-error', error);else reportCallbackError(error);
+      }
+      return this.session === session ? session.sessionId : null;
+    });
+  }
+  requestTarget(sessionId, seq, to, options) {
+    this.batch(() => {
+      const session = this.acceptsRequest(sessionId, seq, false);
+      if (!session || session.resolving) return;
+      // The adapter can certify that measurements and policy inputs have not
+      // changed. Pointer movement within one target then needs only the private
+      // sequence guard; publishing it would rerender every sortable child.
+      if (options?.refresh === false && session.previewSeq === session.seq && session.previewInputVersion === this.previewInputVersion && sameTarget(session.target, to)) {
+        session.seq = seq;
+        session.previewSeq = seq;
+        // Pointer movement inside one logical cell. Reported so an observer can
+        // tell a coalesced packet from one that never arrived.
+        this.lifecycle('request-coalesced', session);
+        return;
+      }
+      const inputVersion = this.previewInputVersion;
+      const previous = this.snapshot;
+      const previousChanged = this.changed;
+      const operationVersion = this.operationVersion;
+      this.lifecycle('request', session);
+      this.calculate(session, seq, to, false);
+      // Reentrant callbacks may already have completed a newer request. Never
+      // mark that request as reusable using this older request's inputs.
+      if (this.session === session && session.seq === seq && this.snapshot.phase === 'dragging') {
+        session.previewSeq = seq;
+        session.previewInputVersion = inputVersion;
+        if (options?.refresh === true && this.batchDepth === 1 && this.operationVersion === operationVersion && this.previewInputVersion === inputVersion && sameTarget(previous.target, to) && sameVisibleSnapshot(previous, this.snapshot)) {
+          // Scrolling can require a fresh visibility/canDrop check without
+          // changing anything React displays. Keep sequence ownership private,
+          // just as for refresh:false, after every validation has completed.
+          this.restore(previous, previousChanged);
+        }
+      }
+    });
+  }
+  release(sessionId, seq, to) {
+    this.batch(() => {
+      const session = this.acceptsRequest(sessionId, seq, true);
+      if (!session || session.resolving) return;
+      // This is receipt on JS, not the physical touch-release timestamp.
+      this.lifecycle('release', session);
+      this.calculate(session, seq, to, true);
+    });
+  }
+  calculate(session, seq, target, final) {
+    // The path accumulates inside one grid zone only; any other target builds
+    // on the committed value again, as the display does.
+    if (!target || target.kind !== 'grid' || target.zoneId !== session.target?.zoneId) session.path.reset();
+    session.seq = seq;
+    session.target = target && (target.kind === 'grid' ? {
+      ...target,
+      position: {
+        ...target.position
+      }
+    } : {
+      ...target
+    });
+    this.update({
+      seq,
+      target: session.target,
+      targetZoneId: target?.zoneId ?? null,
+      validity: 'pending',
+      failureReason: null
+    });
+    this.calculateCandidate(session, final);
+  }
+  location(value, itemId) {
+    return layoutLocation(value, itemId);
+  }
+  isSpatial(target) {
+    return target.kind === 'grid';
+  }
+
+  /** Grid destinations need the span captured at activation. */
+  precheck(session, target) {
+    if (target.kind !== 'grid' || session.gridItemLayouts.has(target.zoneId)) return null;
+    return session.gridItemLayoutErrors.get(target.zoneId) ?? 'invalid-target';
+  }
+  compute(session, target, baseline, committed, from) {
+    // lastValidValue passed validateLayoutState when it was committed, the
+    // API requires immutable values, and an earlier preview was validated as
+    // a complete candidate. Pointer updates therefore validate only the new
+    // candidate instead of the whole baseline again.
+    const result = this.timed(session, 'compute-move', () => computeValidatedLayoutMove({
+      value: baseline.cumulative ? {
+        ...baseline.base,
+        revision: committed.revision
+      } : committed,
+      itemId: session.itemId,
+      to: target,
+      gridItem: target.kind === 'grid' ? session.gridItemLayouts.get(target.zoneId) : undefined,
+      movementPolicy: session.movementPolicy,
+      searchBudget: session.searchBudget
+    }), computed => computed.status, computed => 'attempts' in computed ? computed.attempts : undefined);
+    if (result.status !== 'ok') return {
+      status: result.status
+    };
+    const relative = baseline.cumulative && from ? relativeToCommitted(committed, from, result) : result;
+    return relative.status === 'ok' ? relative : {
+      status: relative.status
+    };
+  }
+
+  // A transient gap between legal positions inside the source grid must not
+  // bounce neighbors back to the committed layout (the same rule as the grid
+  // controller). This affects display only; release still computes its own
+  // candidate and reports the failure reason.
+  keepsPreview(session, target, status) {
+    return target.kind === 'grid' && target.zoneId === session.sourceZoneId && (status === 'impossible' || status === 'unresolved');
+  }
+  prepareProposal(session, result) {
+    return {
+      sessionId: session.sessionId,
+      baseRevision: session.baseRevision,
+      itemId: session.itemId,
+      from: result.from,
+      to: result.to,
+      value: result.value
+    };
+  }
+  askPolicy(_session, _committed, proposal) {
+    return validatedDecision(this.options.canDrop ? this.options.canDrop(proposal) : {
+      allowed: true
+    });
+  }
+  policyFailed(session, seq, error) {
+    if (this.session === session && session.seq === seq && this.snapshot.phase === 'dragging') this.cancelWith('policy-error', error);else reportCallbackError(error);
+  }
+
+  // Policy callbacks receive the complete candidate. Validate it again if a
+  // callback was allowed to run before issuing an atomic state proposal.
+  revalidate(_session, committed, proposal) {
+    return !this.options.canDrop || respondToValidatedDndProposal(this.lastValidValue ?? committed, proposal, true).status === 'accepted';
+  }
+  showCandidate(result) {
+    this.update({
+      validity: 'valid',
+      candidate: result.value,
+      displayValue: result.value
+    });
+  }
+  showFailure(committed, failure, keepPreview) {
+    this.update({
+      validity: 'invalid',
+      failureReason: failure,
+      ...(keepPreview ? {} : {
+        candidate: null,
+        displayValue: committed
+      })
+    });
+  }
+  expectedPhase() {
+    return 'dragging';
+  }
+  sessionEnded() {
+    return false;
+  }
+  finishUnchanged(session) {
+    this.finish(session, {
+      ...this.event(session),
+      outcome: 'unchanged'
+    });
+  }
+  registerProposal(session, proposal, result) {
+    session.proposal = proposal;
+    session.proposalKey = layoutKey(result.value);
+    session.deadline = now() + session.responseTimeoutMs;
+    this.update({
+      phase: 'awaiting-response'
+    });
+    this.armTimer(session);
+    this.lifecycle('proposal', session);
+  }
+  emitChange(proposal, result) {
+    this.options.onChange(result.value, proposal);
+  }
+  changeFailed(session, error) {
+    if (this.session === session) this.interrupt(session, 'change-handler-error', error);else reportCallbackError(error);
+  }
+  armTimer(session) {
+    this.armDeadline(session.deadline, () => this.session === session, () => this.settle(session, 'expired'));
+  }
+  settle(session, response) {
+    if (!session.proposal) return;
+    this.finish(session, {
+      ...this.event(session),
+      outcome: 'proposed',
+      proposal: session.proposal,
+      targetZoneId: session.proposal.to.zoneId,
+      response
+    });
+  }
+  interrupt(session, reason, error) {
+    if (!session.proposal) return;
+    this.finish(session, {
+      ...this.event(session),
+      outcome: 'proposed',
+      proposal: session.proposal,
+      targetZoneId: session.proposal.to.zoneId,
+      response: 'interrupted',
+      reason,
+      ...(error === undefined ? {} : {
+        error
+      })
+    });
+  }
+  cancelWith(reason, error, policyReason) {
+    const session = this.session;
+    if (!session) return;
+    if (session.proposal) {
+      this.interrupt(session, reason, error);
+      return;
+    }
+    this.finish(session, {
+      ...this.event(session),
+      outcome: 'cancelled',
+      reason,
+      ...(session.target ? {
+        targetZoneId: session.target.zoneId
+      } : {}),
+      ...(error === undefined ? {} : {
+        error
+      }),
+      ...(policyReason === undefined ? {} : {
+        policyReason
+      })
+    });
+  }
+  cancel(reason) {
+    this.batch(() => this.cancelWith(reason));
+  }
+  finish(session, event) {
+    if (this.session !== session) return;
+    if (event.outcome === 'proposed') this.lifecycle('response', session);
+    this.lifecycle('end', session);
+    this.clearDeadline();
+    // Clear before callbacks so reentrant end handlers can safely start a new drag.
+    this.session = null;
+    this.update({
+      phase: 'idle',
+      sessionId: null,
+      itemId: null,
+      sourceZoneId: null,
+      targetZoneId: null,
+      target: null,
+      candidate: null,
+      seq: 0,
+      displayValue: this.lastValidValue,
+      validity: this.snapshot.disabled ? 'invalid' : 'valid',
+      gridItemLayouts: new Map(),
+      failureReason: null
+    });
+    try {
+      this.options.onDragEnd?.(event);
+    } catch (error) {
+      reportCallbackError(error);
+    }
+  }
+  dispose() {
+    this.batch(() => {
+      this.disposed = true;
+      this.clearDeadline();
+      this.update({
+        disabled: true
+      });
+      this.cancelWith('unmounted');
+    });
+  }
+}
+//# sourceMappingURL=dndSession.js.map