@lsdsoftware/utils 1.0.2 → 1.0.3

package/README.md

@@ -1,168 +1,62 @@
 # Useful JavaScript utilities
 
 
-### State Machine
-Make implementing state machines less error prone.
-
-```typescript
-import { makeStateMachine } from "@lsdsoftware/utils"
-
-const sm = makeStateMachine({
-  IDLE: {
-    startIt() {
-      //do something
-      return "BUSY"
-    }
-  },
-  BUSY: {
-    stopIt() {
-      //stop doing it
-      return "IDLE"
-    },
-    stopAfterDelay() {
-      return "STOPPING"
-    }
-  },
-  STOPPING: {
-    onTransitionIn(this: any) {
-      //do some clean up
-      this.timer = setTimeout(() => sm.trigger("onDone"), 3000)
-    },
-    onDone() {
-      return "IDLE"
-    },
-    stopIt() {
-      console.log("Already stopping, be patient!")
-      //return void to stay in same state
-    },
-    forceIt(this: any) {
-      clearTimeout(this.timer)
-      return "IDLE"
-    }
-  }
-})
-
-sm.trigger("startIt")
-sm.getState()   //BUSY
-```
-
-
-
-### Message Dispatcher
-Dispatch messages to handlers.  This utility assumes messages are one of three types: request, response, or notification; and follow a predefined format (see type definition below).
+### Line Reader
+Split text into lines
 
 ```typescript
-interface Request {
-  to: string
-  type: "request"
-  id: "string"
-  method: string
-  args: Record<string, unknown>
-}
-
-interface Notification {
-  to: string
-  type: "notification"
-  method: string
-  args: Record<string, unknown>
-}
+import { makeLineReader } from "@lsdsoftware/utils"
 
-interface Response {
-  type: "response"
-  id: string
-  error: unknown
-  result: unknown
-}
+myStream.pipe(makeLineReader(line => console.log(line)))
 ```
 
-Call `dispatch` to dispatch a message you received.  Requests and notifications are dispatched to request handlers that you provide at construction.  Responses are dispatched to response listeners; to listen for a response, call `waitForResponse` with the request ID.
 
-A _myAddress_ parameter provided at construction is used to filter messages.  Only requests and notifications whose _to_ attribute matches _myAddress_ will be processed.
+### Semaphore
+Control concurrent access to resources
 
 ```typescript
-import { makeMessageDispatcher } from "@lsdsoftware/utils"
-
-const requestHandlers = {
-  method1({paramA, paramB}, sender) {
-    //do something
-    return result
-  },
-  async method2({x, y, z}, sender) {
-    //do something
-    return result
-  }
-}
-
-const dispatcher = makeMessageDispatcher("myAddress", requestHandlers)
+import { makeSemaphore } from "@lsdsoftware/utils"
 
-//sample usage
+const semaphore = makeSemaphore(3)
 
-//processing requests and responses
-window.addEventListener("message", event => {
-  const sender = {window: event.source, origin: event.origin}
-  const sendResponse = response => sender.window.postMessage(response, sender.origin)
-  dispatcher.dispatch(event.data, sender, sendResponse)
+const result = await semaphore.runTask(async () => {
+  //use the limited resource
 })
-
-//sending requests
-const id = String(Math.random())
-const request = {to: "someAddress", type: "request", id, method: "someMethod", args: {}}
-iframeWindow.postMessage(request, "*")
-dispatcher.waitForResponse(id)
-  .then(result => console.log(result))
-  .catch(console.error)
 ```
 
 
-
-### Rate Limiter
-Basic rate limiter using the token bucket algorithm.
+### Abortable
+If you have an async operation, e.g.:
 
 ```typescript
-import { RateLimiter } from "@lsdsoftware/utils"
-
-const limiter = new RateLimiter({tokensPerInterval: 5, interval: 60*1000})
-
-function handleRequest(userId, req) {
-  if (limiter.tryRemoveTokens(userId, 1)) return processRequest(req)
-  else throw "Rate limit exceeded"
+async function myTask() {
+  await step1()
+  await step2()
+  await step3()
 }
 ```
 
-
-
-### Connection Manager
-Takes a connect() method and:
-- Only call it to create a connection when needed
-- Automatically retry on failure
-- Automatically reconnect if the previous connection was closed
-- Properly handle shutdown sequence
-
+And you need to make it abortable:
 ```typescript
-import { makeConnectionManager } from "@lsdsoftware/utils"
-
-const conMgr = new ConnectionManager({
-  async connect() {
-    //...
-    return connection
-  },
-  retryDelay: 10*1000
-})
-
-//wherever you need the connection
-const connection = await conMgr.get()
-
-//shutdown
-conMgr.shutdown()
-```
-
+import { makeAbortable } from "@lsdsoftware/utils"
 
+const [abort, abortPromise, checkpoint] = makeAbortable()
 
-### Line Reader
-Split text into lines
+//modify task to support early termination
+async function myTask() {
+  await step1
+  checkpoint()  //will throw if aborted
+  await step2
+  checkpoint()
+  await step3
+}
 
-```typescript
-import { makeLineReader } from "@lsdsoftware/utils"
+//call abort() when you need to
+setTimeout(() => abort(new Error("Timeout")), 5000)
 
-myStream.pipe(makeLineReader(line => console.log(line)))
+//use Promise.race to run your task
+const result = await Promise.race([
+  abortPromise,
+  myTask()
+])
 ```

package/dist/abortable.d.ts

@@ -0,0 +1 @@
+export declare function makeAbortable(): (Promise<never> | ((reason: unknown) => void))[];

package/dist/abortable.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAbortable = void 0;
+function makeAbortable() {
+    let isAborted;
+    let reject;
+    const promise = new Promise((f, r) => reject = r);
+    function abort(reason) {
+        isAborted = { reason };
+        reject(reason);
+    }
+    function checkpoint() {
+        if (isAborted)
+            throw isAborted.reason;
+    }
+    return [
+        abort,
+        promise,
+        checkpoint
+    ];
+}
+exports.makeAbortable = makeAbortable;

package/dist/index.d.ts

@@ -1,7 +1,4 @@
 import { makeLineReader } from "./line-reader";
-import { makeStateMachine } from "./state-machine";
-import { makeConnectionManager } from "./connection-manager";
-import { makeMessageDispatcher } from "./message-dispatcher";
-import { makeRateLimiter } from "./rate-limiter";
 import { makeSemaphore } from "./semaphore";
-export { makeLineReader, makeStateMachine, makeConnectionManager, makeMessageDispatcher, makeRateLimiter, makeSemaphore, };
+import { makeAbortable } from "./abortable";
+export { makeLineReader, makeSemaphore, makeAbortable, };

package/dist/index.js

@@ -1,15 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSemaphore = exports.makeRateLimiter = exports.makeMessageDispatcher = exports.makeConnectionManager = exports.makeStateMachine = exports.makeLineReader = void 0;
+exports.makeAbortable = exports.makeSemaphore = exports.makeLineReader = void 0;
 const line_reader_1 = require("./line-reader");
 Object.defineProperty(exports, "makeLineReader", { enumerable: true, get: function () { return line_reader_1.makeLineReader; } });
-const state_machine_1 = require("./state-machine");
-Object.defineProperty(exports, "makeStateMachine", { enumerable: true, get: function () { return state_machine_1.makeStateMachine; } });
-const connection_manager_1 = require("./connection-manager");
-Object.defineProperty(exports, "makeConnectionManager", { enumerable: true, get: function () { return connection_manager_1.makeConnectionManager; } });
-const message_dispatcher_1 = require("./message-dispatcher");
-Object.defineProperty(exports, "makeMessageDispatcher", { enumerable: true, get: function () { return message_dispatcher_1.makeMessageDispatcher; } });
-const rate_limiter_1 = require("./rate-limiter");
-Object.defineProperty(exports, "makeRateLimiter", { enumerable: true, get: function () { return rate_limiter_1.makeRateLimiter; } });
 const semaphore_1 = require("./semaphore");
 Object.defineProperty(exports, "makeSemaphore", { enumerable: true, get: function () { return semaphore_1.makeSemaphore; } });
+const abortable_1 = require("./abortable");
+Object.defineProperty(exports, "makeAbortable", { enumerable: true, get: function () { return abortable_1.makeAbortable; } });

package/dist/index.test.js

@@ -10,9 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const line_reader_test_1 = require("./line-reader.test");
-const rate_limiter_test_1 = require("./rate-limiter.test");
-const state_machine_test_1 = require("./state-machine.test");
-run(Object.assign(Object.assign(Object.assign({}, line_reader_test_1.default), rate_limiter_test_1.default), state_machine_test_1.default))
+run(Object.assign({}, line_reader_test_1.default))
     .catch(console.error);
 function run(tests) {
     return __awaiter(this, void 0, void 0, function* () {

package/dist/semaphore.d.ts

@@ -1,3 +1,3 @@
 export declare function makeSemaphore(count: number): {
-    runTask<T>(task: () => Promise<T>): Promise<T>;
+    runTask<T>(task: () => Promise<T>, checkpoint?: () => void): Promise<T>;
 };

package/dist/semaphore.js

@@ -13,12 +13,13 @@ exports.makeSemaphore = void 0;
 function makeSemaphore(count) {
     const waiters = [];
     return {
-        runTask(task) {
+        runTask(task, checkpoint) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (count > 0)
                     count--;
                 else
                     yield new Promise(f => waiters.push(f));
+                checkpoint === null || checkpoint === void 0 ? void 0 : checkpoint();
                 try {
                     return yield task();
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsdsoftware/utils",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Useful JavaScript utilities",
   "main": "dist/index.js",
   "files": [

package/dist/connection-manager.d.ts

@@ -1,13 +0,0 @@
-interface Closeable {
-    close(): void;
-    once(event: "close", callback: Function): void;
-}
-export interface ConnectionManager<Connection> {
-    get(): Promise<Connection>;
-    shutdown(): void;
-}
-export declare function makeConnectionManager<Connection extends Closeable>({ connect, retryDelay }: {
-    connect(): Promise<Connection>;
-    retryDelay: number;
-}): ConnectionManager<Connection>;
-export {};

package/dist/connection-manager.js

@@ -1,70 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeConnectionManager = void 0;
-function makeConnectionManager({ connect, retryDelay }) {
-    let connectionPromise;
-    let shutdownFlag = false;
-    return {
-        get() {
-            if (!connectionPromise)
-                connectionPromise = start();
-            return connectionPromise;
-        },
-        shutdown() {
-            shutdownFlag = true;
-            connectionPromise === null || connectionPromise === void 0 ? void 0 : connectionPromise.then(con => con.close()).catch(err => "OK");
-        }
-    };
-    function start() {
-        return new Promise(fulfill => {
-            let firstTime = true;
-            keepAlive(promise => {
-                if (firstTime) {
-                    fulfill(promise);
-                    firstTime = false;
-                }
-                else {
-                    connectionPromise = promise;
-                }
-            });
-        });
-    }
-    function keepAlive(onUpdate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                while (true) {
-                    const promise = connectUntilSucceed();
-                    onUpdate(promise);
-                    const connection = yield promise;
-                    yield new Promise(f => connection.once("close", f));
-                }
-            }
-            catch (err) {
-            }
-        });
-    }
-    function connectUntilSucceed() {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (true) {
-                if (shutdownFlag)
-                    throw new Error("Shutting down");
-                try {
-                    return yield connect();
-                }
-                catch (err) {
-                    yield new Promise(f => setTimeout(f, retryDelay));
-                }
-            }
-        });
-    }
-}
-exports.makeConnectionManager = makeConnectionManager;

package/dist/message-dispatcher.d.ts

@@ -1,29 +0,0 @@
-export type Message = Request | Notification | Response;
-interface Request {
-    to: string;
-    type: "request";
-    id: "string";
-    method: string;
-    args: Record<string, unknown>;
-}
-interface Notification {
-    to: string;
-    type: "notification";
-    method: string;
-    args: Record<string, unknown>;
-}
-interface Response {
-    type: "response";
-    id: string;
-    error: unknown;
-    result: unknown;
-}
-interface RequestHandler {
-    (args: Record<string, unknown>, sender: unknown): unknown;
-}
-export declare function makeMessageDispatcher(myAddress: string, requestHandlers: Record<string, RequestHandler>): {
-    waitForResponse<T>(requestId: string): Promise<T>;
-    dispatch(message: Message, sender: unknown, sendResponse: (res: Response) => void): boolean | void;
-    updateRequestHandlers(newHandlers: typeof requestHandlers): void;
-};
-export {};

package/dist/message-dispatcher.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMessageDispatcher = void 0;
-function makeMessageDispatcher(myAddress, requestHandlers) {
-    const pendingRequests = new Map();
-    return {
-        waitForResponse(requestId) {
-            let pending = pendingRequests.get(requestId);
-            if (!pending)
-                pendingRequests.set(requestId, pending = makePending());
-            return pending.promise;
-        },
-        dispatch(message, sender, sendResponse) {
-            switch (message.type) {
-                case "request": return handleRequest(message, sender, sendResponse);
-                case "notification": return handleNotification(message, sender);
-                case "response": return handleResponse(message);
-            }
-        },
-        updateRequestHandlers(newHandlers) {
-            requestHandlers = newHandlers;
-        }
-    };
-    function makePending() {
-        const pending = {};
-        pending.promise = new Promise((fulfill, reject) => {
-            pending.fulfill = fulfill;
-            pending.reject = reject;
-        });
-        return pending;
-    }
-    function handleRequest(req, sender, sendResponse) {
-        if (req.to == myAddress) {
-            if (requestHandlers[req.method]) {
-                Promise.resolve()
-                    .then(() => requestHandlers[req.method](req.args, sender))
-                    .then(result => sendResponse({ type: "response", id: req.id, result, error: undefined }), error => sendResponse({ type: "response", id: req.id, result: undefined, error }));
-                //let caller know that sendResponse will be called asynchronously
-                return true;
-            }
-            else {
-                console.error("No handler for method", req);
-            }
-        }
-    }
-    function handleNotification(ntf, sender) {
-        if (ntf.to == myAddress) {
-            if (requestHandlers[ntf.method]) {
-                Promise.resolve()
-                    .then(() => requestHandlers[ntf.method](ntf.args, sender))
-                    .catch(error => console.error("Failed to handle notification", ntf, error));
-            }
-            else {
-                console.error("No handler for method", ntf);
-            }
-        }
-    }
-    function handleResponse(res) {
-        const pending = pendingRequests.get(res.id);
-        if (pending) {
-            pendingRequests.delete(res.id);
-            if (res.error)
-                pending.reject(res.error);
-            else
-                pending.fulfill(res.result);
-        }
-        else {
-            console.error("Stray response", res);
-        }
-    }
-}
-exports.makeMessageDispatcher = makeMessageDispatcher;

package/dist/rate-limiter.d.ts

@@ -1,7 +0,0 @@
-export declare function makeRateLimiter({ interval, tokensPerInterval }: {
-    interval: number;
-    tokensPerInterval: number;
-}): {
-    getTokensRemaining(key: unknown): number;
-    tryRemoveTokens(key: unknown, numTokens: number): boolean;
-};

package/dist/rate-limiter.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeRateLimiter = void 0;
-class Bucket {
-    constructor(count, expire) {
-        this.count = count;
-        this.expire = expire;
-    }
-    isValid() {
-        return this.expire > Date.now();
-    }
-}
-function makeRateLimiter({ interval, tokensPerInterval }) {
-    const buckets = new Map();
-    let lastCleanup = Date.now();
-    return {
-        getTokensRemaining(key) {
-            const bucket = buckets.get(key);
-            return (bucket === null || bucket === void 0 ? void 0 : bucket.isValid()) ? bucket.count : tokensPerInterval;
-        },
-        tryRemoveTokens(key, numTokens) {
-            if (Date.now() - lastCleanup > 2 * interval) {
-                lastCleanup = Date.now();
-                for (const [key, bucket] of buckets)
-                    if (!bucket.isValid())
-                        buckets.delete(key);
-            }
-            let bucket = buckets.get(key);
-            if (!(bucket === null || bucket === void 0 ? void 0 : bucket.isValid())) {
-                bucket = new Bucket(tokensPerInterval, Date.now() + interval);
-                buckets.set(key, bucket);
-            }
-            if (numTokens <= bucket.count) {
-                bucket.count -= numTokens;
-                return true;
-            }
-            else {
-                return false;
-            }
-        }
-    };
-}
-exports.makeRateLimiter = makeRateLimiter;

package/dist/rate-limiter.test.d.ts

@@ -1,4 +0,0 @@
-declare const _default: {
-    rateLimiter1(): Promise<void>;
-};
-export default _default;

package/dist/rate-limiter.test.js

@@ -1,39 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const rate_limiter_1 = require("./rate-limiter");
-const assert = require("assert");
-exports.default = {
-    rateLimiter1() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const limiter = (0, rate_limiter_1.makeRateLimiter)({ tokensPerInterval: 5, interval: 2000 });
-            assert(limiter.getTokensRemaining("k1") == 5);
-            assert(limiter.tryRemoveTokens("k1", 3) == true);
-            assert(limiter.getTokensRemaining("k1") == 2);
-            assert(limiter.tryRemoveTokens("k1", 4) == false);
-            assert(limiter.tryRemoveTokens("k2", 4) == true);
-            yield new Promise(f => setTimeout(f, 1500));
-            assert(limiter.tryRemoveTokens("k1", 4) == false);
-            assert(limiter.getTokensRemaining("k1") == 2);
-            yield new Promise(f => setTimeout(f, 1000));
-            assert(limiter.tryRemoveTokens("k1", 4) == true);
-            //new bucket, won't expire until 2 seconds from now
-            assert(limiter.getTokensRemaining("k1") == 1);
-            assert(limiter.tryRemoveTokens("k1", 2) == false);
-            yield new Promise(f => setTimeout(f, 1900));
-            assert(limiter.tryRemoveTokens("k1", 2) == false);
-            assert(limiter.getTokensRemaining("k1") == 1);
-            yield new Promise(f => setTimeout(f, 200));
-            assert(limiter.tryRemoveTokens("k1", 2) == true);
-            assert(limiter.getTokensRemaining("k1") == 3);
-        });
-    }
-};

package/dist/state-machine.d.ts

@@ -1,7 +0,0 @@
-type EventHandler<StateName> = (...args: any) => StateName | void;
-export type State<StateName extends string, EventName extends string> = Partial<Record<EventName | "onTransitionIn", EventHandler<StateName>>>;
-export declare function makeStateMachine<StateName extends string, EventName extends string>(states: Record<StateName | "IDLE", State<StateName, EventName>>): {
-    trigger(eventName: EventName, ...args: any): void;
-    getState(): StateName | "IDLE";
-};
-export {};

package/dist/state-machine.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeStateMachine = void 0;
-function makeStateMachine(states) {
-    var _a, _b;
-    let currentStateName = "IDLE";
-    (_b = (_a = states[currentStateName]).onTransitionIn) === null || _b === void 0 ? void 0 : _b.call(_a);
-    let lock = 0;
-    return {
-        trigger(eventName, ...args) {
-            var _a, _b;
-            if (lock)
-                throw new Error("Cannot trigger an event synchronously while inside an event handler");
-            lock++;
-            try {
-                const currentState = states[currentStateName];
-                if (!(eventName in currentState))
-                    throw new Error("Missing handler " + currentStateName + "." + eventName);
-                const nextStateName = currentState[eventName](...args);
-                if (nextStateName) {
-                    if (!(nextStateName in states))
-                        throw new Error("Missing state " + nextStateName);
-                    currentStateName = nextStateName;
-                    (_b = (_a = states[currentStateName]).onTransitionIn) === null || _b === void 0 ? void 0 : _b.call(_a);
-                }
-            }
-            finally {
-                lock--;
-            }
-        },
-        getState() {
-            return currentStateName;
-        }
-    };
-}
-exports.makeStateMachine = makeStateMachine;

package/dist/state-machine.test.d.ts

@@ -1,4 +0,0 @@
-declare const _default: {
-    stateMachine1(): Promise<void>;
-};
-export default _default;

package/dist/state-machine.test.js

@@ -1,69 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const state_machine_1 = require("./state-machine");
-const assert = require("assert");
-exports.default = {
-    stateMachine1() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sm = (0, state_machine_1.makeStateMachine)({
-                IDLE: {
-                    play() {
-                        return "PLAYING";
-                    },
-                    stop() { },
-                    goto(state) {
-                        return state;
-                    }
-                },
-                PLAYING: {
-                    play() { },
-                    stop() {
-                        return "STOPPING";
-                    }
-                },
-                STOPPING: {
-                    onTransitionIn() {
-                        this.timer = setTimeout(() => sm.trigger("onStop"), 2000);
-                    },
-                    onStop() {
-                        return "IDLE";
-                    },
-                    play() {
-                        clearTimeout(this.timer);
-                        return "PLAYING";
-                    },
-                    stop() { }
-                },
-                STUCK: {}
-            });
-            assert(sm.getState() == "IDLE");
-            sm.trigger("play");
-            assert(sm.getState() == "PLAYING");
-            sm.trigger("stop");
-            assert(sm.getState() == "STOPPING");
-            yield sleep(1000);
-            sm.trigger("play");
-            assert(sm.getState() == "PLAYING");
-            yield sleep(3000);
-            assert(sm.getState() == "PLAYING");
-            sm.trigger("stop");
-            assert(sm.getState() == "STOPPING");
-            yield sleep(3000);
-            assert(sm.getState() == "IDLE");
-            sm.trigger("goto", "STUCK");
-            assert(sm.getState() == "STUCK");
-        });
-    },
-};
-function sleep(ms) {
-    return new Promise(f => setTimeout(f, ms));
-}