front-locker

An useful async locker🔐 for frontend (web).

No need for Database.

Also available on node.js. (But it doesn't work on the node.js program who use multi-process)

中文文档

Install

npm install front-locker

or

yarn add front-locker

Usage

lock

RECOMMEND
Simple to use:

import { lock } from 'front-locker'

lock("locker-name", async () => {
    // Do something async in the lock
    if (!userInfo) {
      userInfo = await login()
    }

})

Do something after lock:

import { lock } from 'front-locker'

lock("another-lock-name", async () => {
  // Do something async in lock
  await xxxx
}).then(() => {
  // Do something after lock
  // ...
}).catch(err => {
  // catch error in lock (and function provided in lock)
  // ...
})

If you need the return value (and you can also use await):

import { lock } from 'front-locker'

(async () => {
  const value = await lock("locker-name", async () => {
      // Do something async in lock
      return await 123
  })
  console.log(value)
  // > 123
})()

If you have difficult to name it, you can use symbol:

import { lock } from 'front-locker'

lock(Symbol(), new Promise(resolve => {
  // You can also use Promise here
  resolve(123)
}))

Also support to set timeout

import {
  lock, wait, Locker,
  LockerTimeoutError, 
  TicketUnvalidError
} from 'front-locker'

// You can also use locker to create lock
const locker = new Locker()

lock(locker, async () => {
    // Do something async in lock
    wait(2000)
}, { timeout: 1000, continueExcute: false }).catch(err => {
  if (err instanceof TicketUnvalidError) {
    // handle this timeout Error when lock function return (if you set {continueExcute: false})
    // ......
  }
  // handle other Error
  // ......
})

Locker

If you want to more flexible, you can use Locker class directly. See more details in the code.

import {
  wait, Locker,
  LockerTimeoutError, 
  TicketUnvalidError
} from 'front-locker'

// You can also use locker to create lock
const locker = new Locker()

(async () => {
  // At the start of the async code you need to lock
  const ticket = await locker.lock()
  // you can also set timeout here
  // const ticket = await locker.lock(5000)
  try {
    // do something async
    // .......
    await wait(1000)
  } finally {
    // At the end of the code you need to lock
    // you should make sure the unlock function will run in any situation, or set a timeout.
    await locker.unlock(ticket)
  }


})()

todo

• [x] Trans to Typescript
• [x] Write Test
• [x] Test Multi-locker Situation
• [x] Add Timeout
• [x] Test Timeout
• [x] Test Error
• [ ] Support Worker