@eclipse-glsp/protocol 2.7.0-next.2 → 2.7.0-next.21

package/lib/utils/math-util.js.map

@@ -1 +1 @@
-{"version":3,"file":"math-util.js","sourceRoot":"","sources":["../../src/utils/math-util.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;kFAckF;;AAElF,8BAEC;AAFD,SAAgB,SAAS,CAAC,GAAW,EAAE,KAAa,EAAE,UAAkB,MAAM,CAAC,OAAO;IAClF,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,IAAI,OAAO,CAAC;AAC5C,CAAC"}
+{"version":3,"file":"math-util.js","sourceRoot":"","sources":["../../src/utils/math-util.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;kFAckF;;;AAQlF,8BAEC;AARD;;;GAGG;AACU,QAAA,oBAAoB,GAAG,IAAI,CAAC;AAEzC,SAAgB,SAAS,CAAC,GAAW,EAAE,KAAa,EAAE,UAAkB,MAAM,CAAC,OAAO;IAClF,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,IAAI,OAAO,CAAC;AAC5C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-glsp/protocol",
-  "version": "2.7.0-next.2+eaf7d17",
+  "version": "2.7.0-next.21+760b637",
   "description": "The protocol definition for client-server communication in GLSP",
   "keywords": [
     "eclipse",
@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "sprotty-protocol": "1.4.0",
-    "uuid": "~10.0.0",
+    "uuid": "~14.0.0",
     "vscode-jsonrpc": "8.2.0"
   },
   "devDependencies": {
@@ -58,5 +58,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "eaf7d170b7f9f665c70146b0423261269edd2a66"
+  "gitHead": "760b637de00febf2dd2cd0b4a97cc90b7cff1bca"
 }

package/src/action-protocol/base-protocol.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021-2023 STMicroelectronics and others.
+ * Copyright (c) 2021-2026 STMicroelectronics and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -82,6 +82,12 @@ export interface RequestAction<Res extends ResponseAction> extends Action, sprot
      * Unique id for this request. In order to match a response to this request, the response needs to have the same id.
      */
     requestId: string;
+    /**
+     * Optional timeout in milliseconds. When set, `requestUntil()` uses this value instead of its
+     * default timeout. This allows the sender to control how long the receiver waits for a response.
+     * Precedence: explicit `timeoutMs` parameter > `action.timeout` > default (2000ms).
+     */
+    timeout?: number;
     /**
      * Used to ensure correct typing. Clients must not use this property
      */

package/src/action-protocol/contexts.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021-2023 STMicroelectronics and others.
+ * Copyright (c) 2021-2026 STMicroelectronics and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -85,3 +85,67 @@ export namespace SetContextActions {
         };
     }
 }
+
+/**
+ * Sent from the server to the client to request the current {@link EditorContext}. This is the server-initiated
+ * counterpart to the `editorContext` parameter that is included in many client-to-server requests.
+ *
+ * All fields in the response represent a snapshot of the client state at the time the response is generated.
+ * There is no guarantee that the state has not changed by the time the server processes the response.
+ *
+ * If you only need a subset of the editor context, consider using a more specific action instead:
+ * - For selected elements only, use `GetSelectionAction`.
+ * - For viewport and canvas bounds only, use `GetViewportAction`.
+ */
+export interface GetEditorContextAction extends RequestAction<EditorContextResult> {
+    kind: typeof GetEditorContextAction.KIND;
+}
+
+export namespace GetEditorContextAction {
+    export const KIND = 'getEditorContext';
+
+    export function is(object: unknown): object is GetEditorContextAction {
+        return RequestAction.hasKind(object, KIND);
+    }
+
+    export function create(options: { requestId?: string; timeout?: number } = {}): GetEditorContextAction {
+        return {
+            kind: KIND,
+            requestId: '',
+            ...options
+        };
+    }
+}
+
+/**
+ * Response to a {@link GetEditorContextAction} containing a snapshot of the client-side editor state.
+ *
+ * All fields in the {@link EditorContext} reflect the state at the time of response generation.
+ * The server should not assume that these values are still current when processing the response,
+ * as the client state may have changed in the meantime.
+ */
+export interface EditorContextResult extends ResponseAction {
+    kind: typeof EditorContextResult.KIND;
+
+    /**
+     * The editor context snapshot.
+     */
+    readonly editorContext: EditorContext;
+}
+
+export namespace EditorContextResult {
+    export const KIND = 'editorContextResult';
+
+    export function is(object: unknown): object is EditorContextResult {
+        return Action.hasKind(object, KIND) && hasObjectProp(object, 'editorContext');
+    }
+
+    export function create(editorContext: EditorContext, options: { responseId?: string } = {}): EditorContextResult {
+        return {
+            kind: KIND,
+            responseId: '',
+            editorContext,
+            ...options
+        };
+    }
+}

package/src/action-protocol/types.ts

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import * as sprotty from 'sprotty-protocol';
-import { Dimension, Point } from 'sprotty-protocol';
+import { Bounds, Dimension, Point, Viewport } from 'sprotty-protocol';
 import { GModelElementSchema } from '../model/model-schema';
 import { AnyObject, hasArrayProp, hasStringProp } from '../utils/type-util';
 import { Action } from './base-protocol';
@@ -121,6 +121,16 @@ export interface EditorContext {
      */
     readonly lastMousePosition?: Point;
 
+    /**
+     * The current viewport (scroll position and zoom level).
+     */
+    readonly viewport?: Viewport;
+
+    /**
+     * The bounds of the canvas element in the browser.
+     */
+    readonly canvasBounds?: Bounds;
+
     /**
      * Custom arguments.
      */

package/src/index.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2024-2025 EclipseSource and others.
+ * Copyright (c) 2024-2026 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -54,6 +54,7 @@ export * from './sprotty-geometry-point';
 export * from './utils/array-util';
 export * from './utils/disposable';
 export * from './utils/event';
+export * from './utils/function-util';
 export * from './utils/geometry-movement';
 export * from './utils/geometry-util';
 export * from './utils/geometry-vector';

package/src/sprotty-geometry-point.spec.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2024 EclipseSource and others.
+ * Copyright (c) 2024-2026 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -127,4 +127,51 @@ describe('Point', () => {
             expect(Point.equals({ x: 1, y: 2 }, { x: 1.0001, y: 2.0001 }, 0.001)).to.be.true;
         });
     });
+
+    describe('isVerticalAligned', () => {
+        it('returns true when both points share the same x coordinate', () => {
+            expect(Point.isVerticalAligned({ x: 10, y: 0 }, { x: 10, y: 100 })).to.be.true;
+        });
+        it('returns true within the default tolerance', () => {
+            expect(Point.isVerticalAligned({ x: 10, y: 0 }, { x: 10.0001, y: 100 })).to.be.true;
+        });
+        it('returns false when the x coordinates differ beyond the default tolerance', () => {
+            expect(Point.isVerticalAligned({ x: 10, y: 0 }, { x: 10.5, y: 100 })).to.be.false;
+        });
+        it('honors an explicit epsilon', () => {
+            expect(Point.isVerticalAligned({ x: 10, y: 0 }, { x: 14, y: 100 }, 5)).to.be.true;
+            expect(Point.isVerticalAligned({ x: 10, y: 0 }, { x: 14, y: 100 }, 3)).to.be.false;
+        });
+    });
+
+    describe('isHorizontalAligned', () => {
+        it('returns true when both points share the same y coordinate', () => {
+            expect(Point.isHorizontalAligned({ x: 0, y: 50 }, { x: 200, y: 50 })).to.be.true;
+        });
+        it('returns true within the default tolerance', () => {
+            expect(Point.isHorizontalAligned({ x: 0, y: 50 }, { x: 200, y: 50.0001 })).to.be.true;
+        });
+        it('returns false when the y coordinates differ beyond the default tolerance', () => {
+            expect(Point.isHorizontalAligned({ x: 0, y: 50 }, { x: 200, y: 50.5 })).to.be.false;
+        });
+        it('honors an explicit epsilon', () => {
+            expect(Point.isHorizontalAligned({ x: 0, y: 50 }, { x: 200, y: 53 }, 5)).to.be.true;
+        });
+    });
+
+    describe('isAxisAligned', () => {
+        it('returns true for vertically aligned points', () => {
+            expect(Point.isAxisAligned({ x: 10, y: 0 }, { x: 10, y: 100 })).to.be.true;
+        });
+        it('returns true for horizontally aligned points', () => {
+            expect(Point.isAxisAligned({ x: 0, y: 50 }, { x: 200, y: 50 })).to.be.true;
+        });
+        it('returns false for points that are neither vertically nor horizontally aligned', () => {
+            expect(Point.isAxisAligned({ x: 0, y: 0 }, { x: 50, y: 50 })).to.be.false;
+        });
+        it('honors an explicit epsilon', () => {
+            expect(Point.isAxisAligned({ x: 10, y: 0 }, { x: 14, y: 100 }, 5)).to.be.true;
+            expect(Point.isAxisAligned({ x: 10, y: 0 }, { x: 14, y: 100 }, 3)).to.be.false;
+        });
+    });
 });

package/src/sprotty-geometry-point.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2024 EclipseSource and others.
+ * Copyright (c) 2024-2026 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -18,7 +18,7 @@
 import { Point } from 'sprotty-protocol/lib/utils/geometry';
 import { Movement } from './utils/geometry-movement';
 import { Vector } from './utils/geometry-vector';
-import { equalUpTo } from './utils/math-util';
+import { ALMOST_EQUAL_EPSILON, equalUpTo } from './utils/math-util';
 import { AnyObject, hasNumberProp } from './utils/type-util';
 
 declare module 'sprotty-protocol/lib/utils/geometry' {
@@ -113,6 +113,37 @@ declare module 'sprotty-protocol/lib/utils/geometry' {
          * @returns the movement from `from` in the `vector` direction
          */
         function moveTowards(from: Point, vector: Vector): Movement;
+
+        /**
+         * Returns whether the given points are vertically aligned, i.e. they
+         * share (approximately) the same x coordinate.
+         *
+         * @param a first point
+         * @param b second point
+         * @param eps tolerance on the x axis (defaults to {@link ALMOST_EQUAL_EPSILON})
+         */
+        function isVerticalAligned(a: Point, b: Point, eps?: number): boolean;
+
+        /**
+         * Returns whether the given points are horizontally aligned, i.e. they
+         * share (approximately) the same y coordinate.
+         *
+         * @param a first point
+         * @param b second point
+         * @param eps tolerance on the y axis (defaults to {@link ALMOST_EQUAL_EPSILON})
+         */
+        function isHorizontalAligned(a: Point, b: Point, eps?: number): boolean;
+
+        /**
+         * Returns whether the given points are axis-aligned, i.e. either
+         * {@link isVerticalAligned vertically} or
+         * {@link isHorizontalAligned horizontally} aligned.
+         *
+         * @param a first point
+         * @param b second point
+         * @param eps tolerance (defaults to {@link ALMOST_EQUAL_EPSILON})
+         */
+        function isAxisAligned(a: Point, b: Point, eps?: number): boolean;
     }
 }
 
@@ -153,4 +184,9 @@ Point.moveTowards = (from: Point, vector: Vector): Movement => {
 
 Point.equals = (one: Point, other: Point, eps?: number): boolean => equalUpTo(one.x, other.x, eps) && equalUpTo(one.y, other.y, eps);
 
+Point.isVerticalAligned = (a: Point, b: Point, eps: number = ALMOST_EQUAL_EPSILON): boolean => equalUpTo(a.x, b.x, eps);
+Point.isHorizontalAligned = (a: Point, b: Point, eps: number = ALMOST_EQUAL_EPSILON): boolean => equalUpTo(a.y, b.y, eps);
+Point.isAxisAligned = (a: Point, b: Point, eps: number = ALMOST_EQUAL_EPSILON): boolean =>
+    Point.isVerticalAligned(a, b, eps) || Point.isHorizontalAligned(a, b, eps);
+
 export { Point };

package/src/utils/array-util.spec.ts

@@ -0,0 +1,205 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { expect } from 'chai';
+import { TypeGuard } from './type-util';
+import {
+    arrayOf,
+    asArray,
+    distinctAdd,
+    first,
+    flatPush,
+    groupBy,
+    isArrayOfClass,
+    isArrayOfType,
+    isStringArray,
+    last,
+    partition,
+    pluck,
+    remove
+} from './array-util';
+
+describe('ArrayUtil', () => {
+    describe('remove', () => {
+        it('should remove a present value and leave others intact', () => {
+            const arr = [1, 2, 3, 4];
+            remove(arr, 2, 4);
+            expect(arr).to.deep.equal([1, 3]);
+        });
+        it('should only remove the first occurrence', () => {
+            const arr = [1, 2, 2, 3];
+            remove(arr, 2);
+            expect(arr).to.deep.equal([1, 2, 3]);
+        });
+        it('should do nothing for absent values', () => {
+            const arr = [1, 2];
+            remove(arr, 99);
+            expect(arr).to.deep.equal([1, 2]);
+        });
+    });
+
+    describe('flatPush', () => {
+        it('should push single values and nested arrays', () => {
+            const arr: number[] = [1];
+            flatPush(arr, [2, [3, 4], 5]);
+            expect(arr).to.deep.equal([1, 2, 3, 4, 5]);
+        });
+    });
+
+    describe('distinctAdd', () => {
+        it('should add only values not already present', () => {
+            const arr = [1, 2];
+            distinctAdd(arr, 2, 3, 4, 1);
+            expect(arr).to.deep.equal([1, 2, 3, 4]);
+        });
+    });
+
+    describe('first', () => {
+        it('should return the first element without n', () => {
+            expect(first([10, 20, 30])).to.equal(10);
+        });
+        it('should return first n elements', () => {
+            expect(first([10, 20, 30], 2)).to.deep.equal([10, 20]);
+        });
+    });
+
+    describe('last', () => {
+        it('should return the last element without n', () => {
+            expect(last([10, 20, 30])).to.equal(30);
+        });
+        it('should return last n elements', () => {
+            expect(last([10, 20, 30], 2)).to.deep.equal([20, 30]);
+        });
+    });
+
+    describe('pluck', () => {
+        it('should extract the given property from each element', () => {
+            const items = [
+                { id: 1, name: 'a' },
+                { id: 2, name: 'b' }
+            ];
+            expect(pluck(items, 'name')).to.deep.equal(['a', 'b']);
+        });
+    });
+
+    describe('asArray', () => {
+        it('should wrap a single value in an array', () => {
+            expect(asArray(5)).to.deep.equal([5]);
+        });
+        it('should return the array as-is', () => {
+            const arr = [1, 2];
+            expect(asArray(arr)).to.equal(arr);
+        });
+    });
+
+    describe('isArrayOfType', () => {
+        const isNumber: TypeGuard<number> = (v: unknown): v is number => typeof v === 'number';
+
+        it('should return true for a matching array', () => {
+            expect(isArrayOfType([1, 2, 3], isNumber)).to.be.true;
+        });
+        it('should return false for an empty array by default', () => {
+            expect(isArrayOfType([], isNumber)).to.be.false;
+        });
+        it('should return true for an empty array with supportEmpty', () => {
+            expect(isArrayOfType([], isNumber, true)).to.be.true;
+        });
+        it('should return false for a mixed array', () => {
+            expect(isArrayOfType([1, 'two'], isNumber)).to.be.false;
+        });
+    });
+
+    describe('isArrayOfClass', () => {
+        it('should return true when all elements are instances of the class', () => {
+            expect(isArrayOfClass([new Date(), new Date()], Date)).to.be.true;
+        });
+        it('should return false for non-instances', () => {
+            expect(isArrayOfClass([{}, new Date()], Date)).to.be.false;
+        });
+    });
+
+    describe('isStringArray', () => {
+        it('should return true for a string array', () => {
+            expect(isStringArray(['a', 'b'])).to.be.true;
+        });
+        it('should return false for a mixed array', () => {
+            expect(isStringArray(['a', 1])).to.be.false;
+        });
+    });
+
+    describe('partition', () => {
+        const isString = (v: unknown): v is string => typeof v === 'string';
+
+        it('should split elements by predicate', () => {
+            const result = partition(['a', 1, 'b', 2] as (string | number)[], isString as TypeGuard<string | number>);
+            expect(result.match).to.deep.equal(['a', 'b']);
+            expect(result.rest).to.deep.equal([1, 2]);
+        });
+        it('should handle all-match case', () => {
+            const result = partition(['a', 'b'], isString as TypeGuard<string>);
+            expect(result.match).to.deep.equal(['a', 'b']);
+            expect(result.rest).to.deep.equal([]);
+        });
+        it('should handle empty array', () => {
+            const result = partition([], isString as TypeGuard<string>);
+            expect(result.match).to.deep.equal([]);
+            expect(result.rest).to.deep.equal([]);
+        });
+    });
+
+    describe('arrayOf', () => {
+        it('should filter out undefined values', () => {
+            expect(arrayOf(1, undefined, 2, undefined, 3)).to.deep.equal([1, 2, 3]);
+        });
+        it('should return empty array when all undefined', () => {
+            expect(arrayOf(undefined, undefined)).to.deep.equal([]);
+        });
+    });
+
+    describe('groupBy', () => {
+        it('should group elements by the key function', () => {
+            const items = [
+                { type: 'fruit', name: 'apple' },
+                { type: 'veggie', name: 'carrot' },
+                { type: 'fruit', name: 'banana' }
+            ];
+            const result = groupBy(items, i => i.type);
+            expect(result.size).to.equal(2);
+            expect(result.get('fruit')!.map(i => i.name)).to.deep.equal(['apple', 'banana']);
+            expect(result.get('veggie')!.map(i => i.name)).to.deep.equal(['carrot']);
+        });
+        it('should return an empty map for an empty array', () => {
+            expect(groupBy([], () => 'k').size).to.equal(0);
+        });
+        it('should support numeric keys', () => {
+            const result = groupBy([1, 2, 3, 4, 5], n => n % 2);
+            expect(result.get(0)).to.deep.equal([2, 4]);
+            expect(result.get(1)).to.deep.equal([1, 3, 5]);
+        });
+        it('should sort groups by key when sorted is true', () => {
+            const items = [
+                { rank: 3, name: 'c' },
+                { rank: 1, name: 'a' },
+                { rank: 2, name: 'b' },
+                { rank: 1, name: 'a2' }
+            ];
+            const result = groupBy(items, i => i.rank, true);
+            const keys = [...result.keys()];
+            expect(keys).to.deep.equal([1, 2, 3]);
+            expect(result.get(1)!.map(i => i.name)).to.deep.equal(['a', 'a2']);
+        });
+    });
+});

package/src/utils/array-util.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2024 EclipseSource and others.
+ * Copyright (c) 2019-2026 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -202,3 +202,20 @@ export function partition<T>(source: T[], matchGuard: TypeGuard<T>): { match: T[
 export function arrayOf<T>(...values: (T | undefined)[]): T[] {
     return values.filter(element => element !== undefined) as T[];
 }
+
+export function groupBy<T, K>(array: T[], keyFn: (item: T) => K, sorted?: boolean): Map<K, T[]> {
+    const grouped = new Map<K, T[]>();
+    for (const item of array) {
+        const key = keyFn(item);
+        const values = grouped.get(key);
+        if (values) {
+            values.push(item);
+        } else {
+            grouped.set(key, [item]);
+        }
+    }
+    if (sorted) {
+        return new Map([...grouped.entries()].sort());
+    }
+    return grouped;
+}

package/src/utils/function-util.spec.ts

@@ -0,0 +1,109 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { debounce } from './function-util';
+
+describe('FunctionUtil', () => {
+    let clock: sinon.SinonFakeTimers;
+
+    beforeEach(() => {
+        clock = sinon.useFakeTimers();
+    });
+
+    afterEach(() => {
+        clock.restore();
+    });
+
+    describe('debounce', () => {
+        it('should invoke the function after the wait period (trailing by default)', () => {
+            const spy = sinon.spy();
+            const debounced = debounce(spy, 100);
+            debounced();
+            expect(spy.called).to.be.false;
+            clock.tick(100);
+            expect(spy.calledOnce).to.be.true;
+        });
+
+        it('should reset the timer on rapid calls and only invoke once', () => {
+            const spy = sinon.spy();
+            const debounced = debounce(spy, 100);
+            debounced();
+            clock.tick(50);
+            debounced();
+            clock.tick(50);
+            expect(spy.called).to.be.false;
+            clock.tick(50);
+            expect(spy.calledOnce).to.be.true;
+        });
+
+        it('should pass the latest arguments', () => {
+            const spy = sinon.spy();
+            const debounced = debounce(spy, 100);
+            debounced('a');
+            debounced('b');
+            clock.tick(100);
+            expect(spy.calledOnce).to.be.true;
+            expect(spy.firstCall.args).to.deep.equal(['b']);
+        });
+
+        it('should invoke immediately with leading: true', () => {
+            const spy = sinon.spy();
+            const debounced = debounce(spy, 100, { leading: true });
+            debounced();
+            expect(spy.calledOnce).to.be.true;
+        });
+
+        it('should not invoke trailing call when leading: true, trailing: false', () => {
+            const spy = sinon.spy();
+            const debounced = debounce(spy, 100, { leading: true, trailing: false });
+            debounced();
+            debounced();
+            expect(spy.calledOnce).to.be.true;
+            clock.tick(100);
+            expect(spy.calledOnce).to.be.true;
+        });
+
+        it('should invoke both leading and trailing when both are true', () => {
+            const spy = sinon.spy();
+            const debounced = debounce(spy, 100, { leading: true, trailing: true });
+            debounced('first');
+            expect(spy.calledOnce).to.be.true;
+            debounced('second');
+            clock.tick(100);
+            expect(spy.calledTwice).to.be.true;
+            expect(spy.secondCall.args).to.deep.equal(['second']);
+        });
+
+        describe('cancel', () => {
+            it('should prevent a pending trailing invocation', () => {
+                const spy = sinon.spy();
+                const debounced = debounce(spy, 100);
+                debounced();
+                debounced.cancel();
+                clock.tick(100);
+                expect(spy.called).to.be.false;
+            });
+
+            it('should be safe to call when nothing is pending', () => {
+                const spy = sinon.spy();
+                const debounced = debounce(spy, 100);
+                expect(() => debounced.cancel()).to.not.throw();
+            });
+        });
+    });
+});