@soxa-ui/plugins 0.0.0-stage → 0.3.0-beta.1

package/dist/custom/slide/pointer/pointer.plugin.d.ts

@@ -0,0 +1,100 @@
+import type { ISlidable } from '@soxa-ui/core';
+import { TBasePlugin } from '../../../base';
+import type { IPluginContext } from '../../../base';
+import type { ISlidePointerPluginOptions, TSlidePointerPluginEvents } from './types';
+/**
+ * TSlidePointerPlugin — указатель перетаскивания: нажатие, протяжка и
+ * отпускание мыши, пальца и пера.
+ *
+ * Операции над DOM — здесь, значение — у владельца: плагин переводит точку
+ * указателя в долю хода по коробке дорожки и зовёт команды `ISlidable`
+ * (`grab`, `press`, `drag`, `release`, `settle`). Какую ручку вести, куда её
+ * поставить и когда слать `commit`, решает владелец. О ползунке плагин не
+ * знает — только контракт, поэтому его возьмёт и следующий компонент с
+ * перетаскиванием.
+ *
+ * Слушает корень, а не дорожку: полоса ручек, отступы под ореол и подписи
+ * меток — тоже цель для пальца, а долю плагин всё равно считает по коробке
+ * дорожки. Нажатие на ручке начинает жест с неё (значение не прыгает), мимо
+ * ручек — ставит туда ближайшую.
+ *
+ * **Щелчок к меткам** — стратегия на режим владельца (`snap`, `strategies/`).
+ * Стратегию выбирает подписка на `change:snap`, а не проверка режима в
+ * обработчике, и жест держит ту, с которой начался. Стратегия видит ручку:
+ * куда та встала бы без щелчка и куда ей встать. Радиус щелчка владелец
+ * держит в px, в долю хода его переводит длина дорожки.
+ *
+ * Своих действий у нажатия нет (`preventDefault`): ни выделения текста, ни
+ * своего фокуса браузера. Фокус получает поле той ручки, которую ведёт жест, —
+ * так клавиши продолжают с того места, где отпустили указатель.
+ *
+ * `click`, которым кончается жест, тоже гасится. Внутри подписи `Label` он
+ * запустил бы её действие — фокус на первое поле подписи, даже если тянули
+ * вторую ручку. С захватом указателя этот `click` приходит в корень, где бы
+ * его ни отпустили.
+ */
+export declare class TSlidePointerPlugin extends TBasePlugin<ISlidable, TSlidePointerPluginEvents> {
+    private _owner;
+    private _root;
+    private _gesture;
+    /** Жест кончился отпусканием: следующий `click` корня — его, а не пользователя */
+    private _swallowClick;
+    /** Класс стратегии щелчка для следующего жеста — по режиму владельца */
+    private _snapStrategy;
+    private _holdDelay;
+    /** Конец стоянки ручки на метке: стратегии снова нужна ручка, хотя указатель стоит */
+    private _wakeTimer;
+    install(ctx: IPluginContext, options?: ISlidePointerPluginOptions): void;
+    destroy(): void;
+    private readonly _onSnapChange;
+    private _attach;
+    private _detach;
+    private readonly _onPointerDown;
+    /**
+     * Нажали на ручку: жест с неё. Ручка не двигается, и стратегия начинает
+     * с того места, где она стоит.
+     */
+    private _grab;
+    /**
+     * Нажали мимо ручек: ближайшая встаёт туда, куда её ставит щелчок, — в
+     * точку нажатия или на метку рядом с ней.
+     */
+    private _press;
+    /** Стратегия щелчка на жест: точки — метки владельца, радиус — доля длины дорожки. */
+    private _snapFor;
+    private readonly _onPointerMove;
+    /**
+     * Повести ручку за указателем жеста — через стратегию щелчка.
+     *
+     * Ядро ведёт ручку за указателем со смещением захвата, поэтому место от
+     * щелчка уходит ему поправкой к указателю: доля, при которой ручка встанет
+     * туда, куда её поставил щелчок. Без щелчка поправка — ноль, и ядро
+     * получает указатель как есть: «ещё не двигали» оно узнаёт по точному
+     * равенству с точкой нажатия. Щелчок оставил ручку на том же месте —
+     * сообщать нечего.
+     */
+    private _follow;
+    /** Стоянка на метке кончается — стратегии снова нужна ручка, хотя указатель стоит. */
+    private _scheduleWake;
+    private readonly _onWake;
+    private _cancelWake;
+    private readonly _onPointerUp;
+    private readonly _onClick;
+    /**
+     * Закончить жест: отпустили, браузер отнял указатель или корень ушёл.
+     * Стратегия решает, довести ли ручку: доводку владелец делает сам, уже без
+     * перетаскивания (`settle`).
+     */
+    private _end;
+    /**
+     * Фокус — полю ведомой ручки. Без прокрутки: страница не должна прыгать к
+     * ручке, которую пользователь и так держит.
+     *
+     * И без кольца (`focusVisible: false`). Фокус ставит скрипт, а видимость
+     * такого фокуса браузер берёт у прошлого: пришёл тот не от мыши — свежая
+     * страница, Tab, — и нажатие мышью включило бы `:focus-visible` поля, а с
+     * ним кольцо ручки и подсказку `auto`. Их держит только фокус с
+     * клавиатуры.
+     */
+    private _focusActive;
+}

package/dist/custom/slide/pointer/pointer.plugin.js

@@ -0,0 +1,268 @@
+import { TBasePlugin } from "../../../base/base.class.js";
+import { TElementPlugin } from "../../element/element.plugin.js";
+import { fractionAt, lengthAlong, slideDirection } from "../direction.js";
+import { fieldOf, thumbsOf, trackOf } from "../parts.js";
+import { TNoneSnapStrategy } from "./strategies/none.strategy.js";
+import { TMagnetSnapStrategy } from "./strategies/magnet.strategy.js";
+import { TPlateauSnapStrategy } from "./strategies/plateau.strategy.js";
+import { TSettleSnapStrategy } from "./strategies/settle.strategy.js";
+import { THoldSnapStrategy } from "./strategies/hold.strategy.js";
+//#region src/custom/slide/pointer/pointer.plugin.ts
+/** Стратегия на каждый режим щелчка: режим выбирает класс, а не ветку в жесте. */
+var SNAP_STRATEGIES = {
+	none: TNoneSnapStrategy,
+	magnet: TMagnetSnapStrategy,
+	plateau: TPlateauSnapStrategy,
+	settle: TSettleSnapStrategy,
+	hold: THoldSnapStrategy
+};
+/** Стоянка ручки на метке в режиме `hold`, мс, — пока опция не задана. */
+var HOLD_DELAY = 250;
+/**
+* Где ручка жеста была бы без щелчка: сдвинута от своего места при нажатии на
+* столько же, на сколько указатель.
+*/
+function unsnapped(gesture) {
+	return gesture.anchor + (gesture.at - gesture.origin);
+}
+/**
+* TSlidePointerPlugin — указатель перетаскивания: нажатие, протяжка и
+* отпускание мыши, пальца и пера.
+*
+* Операции над DOM — здесь, значение — у владельца: плагин переводит точку
+* указателя в долю хода по коробке дорожки и зовёт команды `ISlidable`
+* (`grab`, `press`, `drag`, `release`, `settle`). Какую ручку вести, куда её
+* поставить и когда слать `commit`, решает владелец. О ползунке плагин не
+* знает — только контракт, поэтому его возьмёт и следующий компонент с
+* перетаскиванием.
+*
+* Слушает корень, а не дорожку: полоса ручек, отступы под ореол и подписи
+* меток — тоже цель для пальца, а долю плагин всё равно считает по коробке
+* дорожки. Нажатие на ручке начинает жест с неё (значение не прыгает), мимо
+* ручек — ставит туда ближайшую.
+*
+* **Щелчок к меткам** — стратегия на режим владельца (`snap`, `strategies/`).
+* Стратегию выбирает подписка на `change:snap`, а не проверка режима в
+* обработчике, и жест держит ту, с которой начался. Стратегия видит ручку:
+* куда та встала бы без щелчка и куда ей встать. Радиус щелчка владелец
+* держит в px, в долю хода его переводит длина дорожки.
+*
+* Своих действий у нажатия нет (`preventDefault`): ни выделения текста, ни
+* своего фокуса браузера. Фокус получает поле той ручки, которую ведёт жест, —
+* так клавиши продолжают с того места, где отпустили указатель.
+*
+* `click`, которым кончается жест, тоже гасится. Внутри подписи `Label` он
+* запустил бы её действие — фокус на первое поле подписи, даже если тянули
+* вторую ручку. С захватом указателя этот `click` приходит в корень, где бы
+* его ни отпустили.
+*/
+var TSlidePointerPlugin = class extends TBasePlugin {
+	_owner = null;
+	_root = null;
+	_gesture = null;
+	/** Жест кончился отпусканием: следующий `click` корня — его, а не пользователя */
+	_swallowClick = false;
+	/** Класс стратегии щелчка для следующего жеста — по режиму владельца */
+	_snapStrategy = TNoneSnapStrategy;
+	_holdDelay = HOLD_DELAY;
+	/** Конец стоянки ручки на метке: стратегии снова нужна ручка, хотя указатель стоит */
+	_wakeTimer = null;
+	install(ctx, options) {
+		super.install(ctx, options);
+		this._holdDelay = options?.holdDelay ?? this._holdDelay;
+		this._owner = ctx.getInstance();
+		const element = ctx.get(TElementPlugin);
+		element?.events.on("ready", (node) => this._attach(node));
+		element?.events.on("removed", () => this._detach());
+		this._snapStrategy = SNAP_STRATEGIES[this._owner?.snap ?? "none"];
+		this._owner?.events.on("change:snap", this._onSnapChange);
+	}
+	destroy() {
+		this._detach();
+		this._owner?.events.off("change:snap", this._onSnapChange);
+		this._owner = null;
+		super.destroy();
+	}
+	_onSnapChange = ({ newValue: snap }) => {
+		this._snapStrategy = SNAP_STRATEGIES[snap];
+	};
+	_attach(root) {
+		this._detach();
+		this._root = root;
+		const target = root;
+		target.addEventListener("pointerdown", this._onPointerDown);
+		target.addEventListener("pointermove", this._onPointerMove);
+		target.addEventListener("pointerup", this._onPointerUp);
+		target.addEventListener("pointercancel", this._onPointerUp);
+		target.addEventListener("lostpointercapture", this._onPointerUp);
+		target.addEventListener("click", this._onClick);
+	}
+	_detach() {
+		this._end();
+		const target = this._root;
+		target?.removeEventListener("pointerdown", this._onPointerDown);
+		target?.removeEventListener("pointermove", this._onPointerMove);
+		target?.removeEventListener("pointerup", this._onPointerUp);
+		target?.removeEventListener("pointercancel", this._onPointerUp);
+		target?.removeEventListener("lostpointercapture", this._onPointerUp);
+		target?.removeEventListener("click", this._onClick);
+		this._root = null;
+		this._swallowClick = false;
+	}
+	_onPointerDown = (event) => {
+		const owner = this._owner;
+		const root = this._root;
+		if (!owner || !root || this._gesture || event.button !== 0) return;
+		const track = trackOf(owner, root);
+		if (!track) return;
+		const direction = slideDirection(owner, root);
+		const box = track.getBoundingClientRect();
+		const fraction = fractionAt(direction, box, event);
+		const thumb = thumbsOf(owner, track).findIndex((node) => event.target instanceof Node && node.contains(event.target));
+		const start = {
+			pointer: event.pointerId,
+			track,
+			direction,
+			origin: fraction
+		};
+		const gesture = thumb >= 0 ? this._grab(owner, thumb, start, box) : this._press(owner, start, box);
+		if (!gesture) return;
+		event.preventDefault();
+		this._gesture = gesture;
+		this._swallowClick = false;
+		this._scheduleWake(gesture.snap.wakeAt);
+		if ("setPointerCapture" in root) root.setPointerCapture(event.pointerId);
+		this._focusActive();
+	};
+	/**
+	* Нажали на ручку: жест с неё. Ручка не двигается, и стратегия начинает
+	* с того места, где она стоит.
+	*/
+	_grab(owner, thumb, start, box) {
+		if (!owner.grab(thumb, start.origin)) return null;
+		const anchor = owner.fractions[thumb];
+		const snap = this._snapFor(owner, start.direction, box, anchor);
+		return {
+			...start,
+			snap,
+			anchor,
+			at: start.origin,
+			placed: anchor
+		};
+	}
+	/**
+	* Нажали мимо ручек: ближайшая встаёт туда, куда её ставит щелчок, — в
+	* точку нажатия или на метку рядом с ней.
+	*/
+	_press(owner, start, box) {
+		const anchor = start.origin;
+		const snap = this._snapFor(owner, start.direction, box, anchor);
+		const placed = snap.follow(anchor, performance.now());
+		if (!owner.press(placed)) return null;
+		return {
+			...start,
+			snap,
+			anchor,
+			at: start.origin,
+			placed
+		};
+	}
+	/** Стратегия щелчка на жест: точки — метки владельца, радиус — доля длины дорожки. */
+	_snapFor(owner, direction, box, anchor) {
+		const length = lengthAlong(direction, box);
+		return new this._snapStrategy({
+			points: owner.snapPoints,
+			radius: length > 0 ? owner.snapRadius / length : 0,
+			anchor,
+			holdDelay: this._holdDelay
+		});
+	}
+	_onPointerMove = (event) => {
+		const gesture = this._gesture;
+		if (!gesture || event.pointerId !== gesture.pointer) return;
+		gesture.at = fractionAt(gesture.direction, gesture.track.getBoundingClientRect(), event);
+		this._follow(gesture);
+	};
+	/**
+	* Повести ручку за указателем жеста — через стратегию щелчка.
+	*
+	* Ядро ведёт ручку за указателем со смещением захвата, поэтому место от
+	* щелчка уходит ему поправкой к указателю: доля, при которой ручка встанет
+	* туда, куда её поставил щелчок. Без щелчка поправка — ноль, и ядро
+	* получает указатель как есть: «ещё не двигали» оно узнаёт по точному
+	* равенству с точкой нажатия. Щелчок оставил ручку на том же месте —
+	* сообщать нечего.
+	*/
+	_follow(gesture) {
+		const target = unsnapped(gesture);
+		const placed = gesture.snap.follow(target, performance.now());
+		this._scheduleWake(gesture.snap.wakeAt);
+		if (placed === gesture.placed) return;
+		gesture.placed = placed;
+		this._owner?.drag(gesture.at + (placed - target));
+		this._focusActive();
+	}
+	/** Стоянка на метке кончается — стратегии снова нужна ручка, хотя указатель стоит. */
+	_scheduleWake(at) {
+		this._cancelWake();
+		if (at === void 0) return;
+		this._wakeTimer = setTimeout(this._onWake, Math.max(0, at - performance.now()));
+	}
+	_onWake = () => {
+		this._wakeTimer = null;
+		if (this._gesture) this._follow(this._gesture);
+	};
+	_cancelWake() {
+		if (this._wakeTimer === null) return;
+		clearTimeout(this._wakeTimer);
+		this._wakeTimer = null;
+	}
+	_onPointerUp = (event) => {
+		const gesture = this._gesture;
+		if (!gesture || event.pointerId !== gesture.pointer) return;
+		this._swallowClick = event.type === "pointerup";
+		this._end();
+	};
+	_onClick = (event) => {
+		if (!this._swallowClick) return;
+		this._swallowClick = false;
+		event.preventDefault();
+	};
+	/**
+	* Закончить жест: отпустили, браузер отнял указатель или корень ушёл.
+	* Стратегия решает, довести ли ручку: доводку владелец делает сам, уже без
+	* перетаскивания (`settle`).
+	*/
+	_end() {
+		const gesture = this._gesture;
+		if (!gesture) return;
+		this._gesture = null;
+		this._cancelWake();
+		const settle = gesture.snap.release(unsnapped(gesture));
+		if (settle === void 0) this._owner?.release();
+		else this._owner?.settle(settle);
+	}
+	/**
+	* Фокус — полю ведомой ручки. Без прокрутки: страница не должна прыгать к
+	* ручке, которую пользователь и так держит.
+	*
+	* И без кольца (`focusVisible: false`). Фокус ставит скрипт, а видимость
+	* такого фокуса браузер берёт у прошлого: пришёл тот не от мыши — свежая
+	* страница, Tab, — и нажатие мышью включило бы `:focus-visible` поля, а с
+	* ним кольцо ручки и подсказку `auto`. Их держит только фокус с
+	* клавиатуры.
+	*/
+	_focusActive() {
+		const owner = this._owner;
+		const gesture = this._gesture;
+		const index = owner?.activeThumb;
+		if (!owner || !gesture || index === void 0) return;
+		const field = fieldOf(thumbsOf(owner, gesture.track)[index]);
+		if (field && field.ownerDocument.activeElement !== field) field.focus({
+			preventScroll: true,
+			focusVisible: false
+		});
+	}
+};
+//#endregion
+export { TSlidePointerPlugin };

package/dist/custom/slide/pointer/strategies/base.strategy.d.ts

@@ -0,0 +1,16 @@
+import type { ISlideSnapStrategy, TSlideSnapContext } from './types';
+/**
+ * TSlideSnapStrategy — общая часть стратегий щелчка: ручка идёт за
+ * указателем, отпущенная остаётся, где её отпустили, и ждать нечего.
+ *
+ * Режим — наследник, который меняет одно из трёх: веток по режиму здесь нет.
+ * Наследник без изменений — режим `none` (`TNoneSnapStrategy`).
+ */
+export declare abstract class TSlideSnapStrategy implements ISlideSnapStrategy {
+    protected readonly _points: readonly number[];
+    protected readonly _radius: number;
+    constructor({ points, radius }: TSlideSnapContext);
+    get wakeAt(): number | undefined;
+    follow(target: number, _now: number): number;
+    release(_target: number): number | undefined;
+}

package/dist/custom/slide/pointer/strategies/base.strategy.js

@@ -0,0 +1,23 @@
+//#region src/custom/slide/pointer/strategies/base.strategy.ts
+/**
+* TSlideSnapStrategy — общая часть стратегий щелчка: ручка идёт за
+* указателем, отпущенная остаётся, где её отпустили, и ждать нечего.
+*
+* Режим — наследник, который меняет одно из трёх: веток по режиму здесь нет.
+* Наследник без изменений — режим `none` (`TNoneSnapStrategy`).
+*/
+var TSlideSnapStrategy = class {
+	_points;
+	_radius;
+	constructor({ points, radius }) {
+		this._points = points;
+		this._radius = radius > 0 ? radius : 0;
+	}
+	get wakeAt() {}
+	follow(target, _now) {
+		return target;
+	}
+	release(_target) {}
+};
+//#endregion
+export { TSlideSnapStrategy };

package/dist/custom/slide/pointer/strategies/hold.strategy.d.ts

@@ -0,0 +1,28 @@
+import { TSlideSnapStrategy } from './base.strategy';
+import type { TSlideSnapContext } from './types';
+/**
+ * THoldSnapStrategy — задержка (`hold`): ручка, которая прошла или достигла
+ * метки, стоит на ней `holdDelay` мс и потом догоняет указатель. Отпустили,
+ * пока стоит, — ручка осталась на метке.
+ *
+ * Время стратегия получает с каждым шагом (`now`), а не заводит таймер сама:
+ * когда стоянка кончится, она сообщает (`wakeAt`), и плагин зовёт её снова,
+ * хотя указатель стоит. Пока ручка стоит, другие метки на пути не держат:
+ * догнав указатель, она проходит их без остановки.
+ *
+ * Путь — ручки, а за краями хода её нет: указатель за краем дорожки держит
+ * её на краю. Поэтому путь прижат к ходу — метку на краю ручка, вернувшаяся
+ * из-за края, покидает, а не пересекает снова.
+ */
+export declare class THoldSnapStrategy extends TSlideSnapStrategy {
+    private readonly _delay;
+    /**
+     * Где ручка была бы без щелчка шагом раньше, в пределах хода, — от неё
+     * виден путь через метку
+     */
+    private _last;
+    private _stop;
+    constructor(context: TSlideSnapContext);
+    get wakeAt(): number | undefined;
+    follow(target: number, now: number): number;
+}

package/dist/custom/slide/pointer/strategies/hold.strategy.js

@@ -0,0 +1,48 @@
+import { TSlideSnapStrategy } from "./base.strategy.js";
+import { crossedPoint, withinTravel } from "./points.js";
+//#region src/custom/slide/pointer/strategies/hold.strategy.ts
+/**
+* THoldSnapStrategy — задержка (`hold`): ручка, которая прошла или достигла
+* метки, стоит на ней `holdDelay` мс и потом догоняет указатель. Отпустили,
+* пока стоит, — ручка осталась на метке.
+*
+* Время стратегия получает с каждым шагом (`now`), а не заводит таймер сама:
+* когда стоянка кончится, она сообщает (`wakeAt`), и плагин зовёт её снова,
+* хотя указатель стоит. Пока ручка стоит, другие метки на пути не держат:
+* догнав указатель, она проходит их без остановки.
+*
+* Путь — ручки, а за краями хода её нет: указатель за краем дорожки держит
+* её на краю. Поэтому путь прижат к ходу — метку на краю ручка, вернувшаяся
+* из-за края, покидает, а не пересекает снова.
+*/
+var THoldSnapStrategy = class extends TSlideSnapStrategy {
+	_delay;
+	/**
+	* Где ручка была бы без щелчка шагом раньше, в пределах хода, — от неё
+	* виден путь через метку
+	*/
+	_last;
+	_stop = void 0;
+	constructor(context) {
+		super(context);
+		this._delay = context.holdDelay;
+		this._last = withinTravel(context.anchor);
+	}
+	get wakeAt() {
+		return this._stop?.until;
+	}
+	follow(target, now) {
+		const from = this._last;
+		const to = withinTravel(target);
+		this._last = to;
+		if (this._stop && now < this._stop.until) return this._stop.point;
+		const point = crossedPoint(this._points, from, to);
+		this._stop = point === void 0 ? void 0 : {
+			point,
+			until: now + this._delay
+		};
+		return point ?? target;
+	}
+};
+//#endregion
+export { THoldSnapStrategy };

package/dist/custom/slide/pointer/strategies/index.d.ts

@@ -0,0 +1,7 @@
+export { TSlideSnapStrategy } from './base.strategy';
+export { TNoneSnapStrategy } from './none.strategy';
+export { TMagnetSnapStrategy } from './magnet.strategy';
+export { TPlateauSnapStrategy } from './plateau.strategy';
+export { TSettleSnapStrategy } from './settle.strategy';
+export { THoldSnapStrategy } from './hold.strategy';
+export type { ISlideSnapStrategy, TSlideSnapContext, TSlideSnapStrategyCtor, TPlateauKnot, THoldStop, } from './types';

package/dist/custom/slide/pointer/strategies/magnet.strategy.d.ts

@@ -0,0 +1,11 @@
+import { TSlideSnapStrategy } from './base.strategy';
+/**
+ * TMagnetSnapStrategy — притяжение (`magnet`): в радиусе метки ручка стоит на
+ * ней, за радиусом идёт за указателем.
+ *
+ * Так же притягивает и нажатие мимо ручек: нажали рядом с меткой — ручка
+ * встала на метку.
+ */
+export declare class TMagnetSnapStrategy extends TSlideSnapStrategy {
+    follow(target: number): number;
+}

package/dist/custom/slide/pointer/strategies/magnet.strategy.js

@@ -0,0 +1,17 @@
+import { TSlideSnapStrategy } from "./base.strategy.js";
+import { nearestPoint } from "./points.js";
+//#region src/custom/slide/pointer/strategies/magnet.strategy.ts
+/**
+* TMagnetSnapStrategy — притяжение (`magnet`): в радиусе метки ручка стоит на
+* ней, за радиусом идёт за указателем.
+*
+* Так же притягивает и нажатие мимо ручек: нажали рядом с меткой — ручка
+* встала на метку.
+*/
+var TMagnetSnapStrategy = class extends TSlideSnapStrategy {
+	follow(target) {
+		return nearestPoint(this._points, target, this._radius) ?? target;
+	}
+};
+//#endregion
+export { TMagnetSnapStrategy };

package/dist/custom/slide/pointer/strategies/none.strategy.d.ts

@@ -0,0 +1,7 @@
+import { TSlideSnapStrategy } from './base.strategy';
+/**
+ * TNoneSnapStrategy — щелчка нет (`none`): ручка идёт за указателем, метки
+ * её не притягивают. Всё нужное уже в общей части.
+ */
+export declare class TNoneSnapStrategy extends TSlideSnapStrategy {
+}

package/dist/custom/slide/pointer/strategies/none.strategy.js

@@ -0,0 +1,9 @@
+import { TSlideSnapStrategy } from "./base.strategy.js";
+//#region src/custom/slide/pointer/strategies/none.strategy.ts
+/**
+* TNoneSnapStrategy — щелчка нет (`none`): ручка идёт за указателем, метки
+* её не притягивают. Всё нужное уже в общей части.
+*/
+var TNoneSnapStrategy = class extends TSlideSnapStrategy {};
+//#endregion
+export { TNoneSnapStrategy };

package/dist/custom/slide/pointer/strategies/plateau.strategy.d.ts

@@ -0,0 +1,24 @@
+import { TSlideSnapStrategy } from './base.strategy';
+import type { TSlideSnapContext } from './types';
+/**
+ * TPlateauSnapStrategy — плато (`plateau`): метка занимает два радиуса хода
+ * указателя, и всё это время ручка стоит на ней. Промежутки между метками
+ * сжаты — там ручка идёт чуть быстрее указателя, — и недостижимых значений
+ * нет: уйти с метки — протащить указатель за плато.
+ *
+ * Перевод — ломаная (`TPlateauKnot`): на плато ручка стоит, между плато идёт
+ * по прямой, края хода остаются краями. С каждой стороны метки плато не
+ * шире радиуса и не больше четверти промежутка до соседней метки — половины
+ * до края хода: между плато остаётся хотя бы половина промежутка, и ручка там
+ * быстрее указателя не больше чем вдвое.
+ *
+ * Ручка, которую взяли вне плато, стоит на месте: её место — лишний узел
+ * ломаной (`anchor`), и промежуток сжат по обе стороны от него. Иначе первое
+ * же движение перенесло бы ручку туда, где её место на сжатой шкале. Взятая
+ * на плато встаёт на его метку.
+ */
+export declare class TPlateauSnapStrategy extends TSlideSnapStrategy {
+    private readonly _knots;
+    constructor(context: TSlideSnapContext);
+    follow(target: number): number;
+}

package/dist/custom/slide/pointer/strategies/plateau.strategy.js

@@ -0,0 +1,81 @@
+import { TSlideSnapStrategy } from "./base.strategy.js";
+import { withinTravel } from "./points.js";
+//#region src/custom/slide/pointer/strategies/plateau.strategy.ts
+/**
+* TPlateauSnapStrategy — плато (`plateau`): метка занимает два радиуса хода
+* указателя, и всё это время ручка стоит на ней. Промежутки между метками
+* сжаты — там ручка идёт чуть быстрее указателя, — и недостижимых значений
+* нет: уйти с метки — протащить указатель за плато.
+*
+* Перевод — ломаная (`TPlateauKnot`): на плато ручка стоит, между плато идёт
+* по прямой, края хода остаются краями. С каждой стороны метки плато не
+* шире радиуса и не больше четверти промежутка до соседней метки — половины
+* до края хода: между плато остаётся хотя бы половина промежутка, и ручка там
+* быстрее указателя не больше чем вдвое.
+*
+* Ручка, которую взяли вне плато, стоит на месте: её место — лишний узел
+* ломаной (`anchor`), и промежуток сжат по обе стороны от него. Иначе первое
+* же движение перенесло бы ручку туда, где её место на сжатой шкале. Взятая
+* на плато встаёт на его метку.
+*/
+var TPlateauSnapStrategy = class extends TSlideSnapStrategy {
+	_knots;
+	constructor(context) {
+		super(context);
+		this._knots = anchored(plateau(this._points, this._radius), context.anchor);
+	}
+	follow(target) {
+		return along(this._knots, target);
+	}
+};
+/**
+* Ломаная плато: края хода и по два узла на метку — начало и конец её плато.
+* Узел, который не дальше предыдущего, пропущен: метка на краю хода и нулевой
+* радиус дают узел поверх соседнего с тем же «встаёт».
+*/
+function plateau(points, radius) {
+	const last = points.length - 1;
+	const knots = [];
+	const add = (knot) => {
+		const previous = knots.at(-1);
+		if (!previous || knot[0] > previous[0]) knots.push(knot);
+	};
+	add([0, 0]);
+	points.forEach((point, index) => {
+		const before = index > 0 ? (point - points[index - 1]) / 4 : point / 2;
+		const after = index < last ? (points[index + 1] - point) / 4 : (1 - point) / 2;
+		add([point - Math.min(radius, before), point]);
+		add([point + Math.min(radius, after), point]);
+	});
+	add([1, 1]);
+	return knots;
+}
+/**
+* Ломаная с узлом в якоре — там, где ручка стоит в начале жеста. Якорь на
+* плато или в узле ничего не добавляет: на плато ручка и так встаёт на метку,
+* а узел уже на своём месте.
+*/
+function anchored(knots, anchor) {
+	const index = knots.findIndex(([target]) => target >= anchor);
+	if (index <= 0 || knots[index][0] === anchor) return knots;
+	if (knots[index - 1][1] === knots[index][1]) return knots;
+	return [
+		...knots.slice(0, index),
+		[anchor, anchor],
+		...knots.slice(index)
+	];
+}
+/**
+* Где встаёт ручка, которая без щелчка была бы в `target`: по ломаной, за
+* краями хода — край. В узле — ровно его «встаёт»: якорь отдаётся как есть.
+*/
+function along(knots, target) {
+	const at = withinTravel(target);
+	let index = 0;
+	while (index < knots.length - 2 && knots[index + 1][0] <= at) index++;
+	const [fromTarget, fromPlaced] = knots[index];
+	const [toTarget, toPlaced] = knots[index + 1];
+	return fromPlaced + (at - fromTarget) * (toPlaced - fromPlaced) / (toTarget - fromTarget);
+}
+//#endregion
+export { TPlateauSnapStrategy };