@wodzik/cubecore 0.1.6 → 0.1.8

package/bluetooth/rotations.d.ts

@@ -60,9 +60,21 @@ export declare function heldMove(move: string, grip: Grip): string;
  * y2, y y' = nothing), and slices / wide moves read from face moves with
  * the core's rotation.
  */
-export declare function heldTokens(moves: readonly TimedMove[], startRotation: string, rotations: readonly RotationRecord[]): HeldToken[];
+export interface HeldOptions {
+    /**
+     * Wide moves to read from one face turn and the core's rotation — the rest
+     * stay a face turn and a rotation. Default r, l, f, b: a u or d is almost
+     * always a U / D turn and a y regrip.
+     */
+    wide?: readonly string[];
+    /** Slices to read from both faces of an axis and the core's rotation (default M, E, S); the rest stay two face turns and a rotation. */
+    slices?: readonly string[];
+}
+export declare const DEFAULT_WIDE: readonly string[];
+export declare const DEFAULT_SLICES: readonly string[];
+export declare function heldTokens(moves: readonly TimedMove[], startRotation: string, rotations: readonly RotationRecord[], options?: HeldOptions): HeldToken[];
 /** A rotation and the face moves around it that make a slice / wide move → that move. */
-export declare function mergeSlicesAndWides(tokens: readonly HeldToken[]): HeldToken[];
+export declare function mergeSlicesAndWides(tokens: readonly HeldToken[], allowed?: ReadonlySet<string>): HeldToken[];
 export interface GripEvent {
     /** Moves the session had reported before it (its stream position). */
     after: number;

package/bluetooth/rotations.js

@@ -28,16 +28,12 @@ export function heldMove(move, grip) {
     const canonical = Object.keys(grip.face).find((c) => grip.face[c] === face);
     return canonical ? canonical + move.slice(1) : move;
 }
-/**
- * The moves as the solver saw them: re-lettered for the grip each was made
- * in (`startRotation` from white top / green front — U up, F front — then
- * the rotations), rotations between them (back-to-back ones combined: y y =
- * y2, y y' = nothing), and slices / wide moves read from face moves with
- * the core's rotation.
- */
-export function heldTokens(moves, startRotation, rotations) {
+export const DEFAULT_WIDE = ["r", "l", "f", "b"];
+export const DEFAULT_SLICES = ["M", "E", "S"];
+export function heldTokens(moves, startRotation, rotations, options = {}) {
+    const allowed = new Set([...(options.wide ?? DEFAULT_WIDE), ...(options.slices ?? DEFAULT_SLICES)]);
     let grip = rotateGrip(IDENTITY_GRIP, startRotation);
-    const rots = snapToSlices(moves, grip, [...rotations].sort((a, b) => a.after - b.after || a.t - b.t));
+    const rots = snapToSlices(moves, grip, [...rotations].sort((a, b) => a.after - b.after || a.t - b.t), allowed);
     const tokens = [];
     let r = 0;
     for (let i = 0; i <= moves.length; i++) {
@@ -58,7 +54,7 @@ export function heldTokens(moves, startRotation, rotations) {
         if (i < moves.length)
             tokens.push({ kind: "move", move: heldMove(moves[i].move, grip), t: moves[i].t, index: i });
     }
-    return mergeSlicesAndWides(tokens);
+    return mergeSlicesAndWides(tokens, allowed);
 }
 // ─── slices and wide moves ──────────────────────────────────────────────
 /** A slice / wide move's face moves and its rotation, reported this far apart (ms), are one move. */
@@ -74,12 +70,13 @@ const AXIS_FACES = { x: ["R", "L"], y: ["U", "D"], z: ["F", "B"] };
 const SLICE_WIDE = ["M", "E", "S", "r", "l", "u", "d", "f", "b"].flatMap((f) => [f, `${f}'`, `${f}2`]);
 const effect = (alg) => applyMoves(solvedState(), alg).join();
 const SLICE_WIDE_EFFECT = new Map();
-/** The slice / wide move the group (held letters and a rotation) amounts to, or null. */
-function sliceOrWide(group) {
+/** The slice / wide move the group (held letters and a rotation) amounts to, if `allowed` (by its letter), or null. */
+function sliceOrWide(group, allowed) {
     if (SLICE_WIDE_EFFECT.size === 0)
         for (const m of SLICE_WIDE)
             SLICE_WIDE_EFFECT.set(effect(m), m);
-    return SLICE_WIDE_EFFECT.get(effect(group.join(" "))) ?? null;
+    const m = SLICE_WIDE_EFFECT.get(effect(group.join(" ")));
+    return m && allowed.has(m[0]) ? m : null;
 }
 /**
  * The consecutive run (up to MAX_GROUP) of moves on the axis nearest to
@@ -111,7 +108,7 @@ function axisRun(moves, from, dir, onAxis, t) {
  * slice's signature (both faces of the axis) is trusted: one face and a
  * rotation could as well be a face turn and a real regrip.
  */
-function snapToSlices(moves, startGrip, rotations) {
+function snapToSlices(moves, startGrip, rotations, allowed) {
     let grip = startGrip;
     const out = rotations.map((r) => ({ ...r }));
     for (const r of out) {
@@ -133,7 +130,7 @@ function snapToSlices(moves, startGrip, rotations) {
                 const far = idx.some((j) => Math.abs(moves[j].t - r.t) > SNAP_MS);
                 if (far && new Set(idx.map((j) => moves[j].move[0])).size < 2)
                     continue;
-                if (sliceOrWide([...letters(idx), r.move])) {
+                if (sliceOrWide([...letters(idx), r.move], allowed)) {
                     r.after = after;
                     // It happened with those moves: its time is theirs.
                     r.t = moves[after > idx[0] ? idx.at(-1) : idx[0]].t;
@@ -146,7 +143,7 @@ function snapToSlices(moves, startGrip, rotations) {
     return out.sort((a, b) => a.after - b.after || a.t - b.t);
 }
 /** A rotation and the face moves around it that make a slice / wide move → that move. */
-export function mergeSlicesAndWides(tokens) {
+export function mergeSlicesAndWides(tokens, allowed = new Set([...DEFAULT_WIDE, ...DEFAULT_SLICES])) {
     const out = [...tokens];
     for (let k = 0; k < out.length; k++) {
         const rot = out[k];
@@ -165,7 +162,7 @@ export function mergeSlicesAndWides(tokens) {
             const groupMoves = group.filter((t) => t.kind === "move");
             if (groupMoves.length !== group.length - 1 || groupMoves.some((m) => Math.abs(m.t - rot.t) > SAME_MOMENT_MS))
                 continue;
-            const merged = sliceOrWide(group.map((t) => t.move));
+            const merged = sliceOrWide(group.map((t) => t.move), allowed);
             if (!merged)
                 continue;
             const first = groupMoves[0];

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "A 3×3×3 cube library for the web, built around smart (Bluetooth) cubes: state, notation, methods, solvers and scrambles, a three.js renderer with skins, pictures, web components, React bindings.",
   "license": "MPL-2.0",
   "author": "Tomasz Wodzikowski <wodziszczakow@gmail.com>",