feat: add SYNC priority and sleep

solkimicreb · solkimicreb · commit bf6a0670fae7 · 2018-03-23T07:28:33.000+01:00
diff --git a/.npmrc b/.npmrc
diff --git a/README.md b/README.md
@@ -67,6 +67,7 @@ Queue instances can be created with the `Queue` constructor. The constructor req
 
 The following priorities are exported on the `priorities` object.
 
+- `priorities.SYNC`: Tasks are executed right away synchronously.
 - `priorities.CRITICAL`: Tasks are executed ASAP (always before the next repaint in the browser).
 - `priorities.HIGH`: Tasks are executed when there is free time and no more pending critical tasks.
 - `priorities.LOW`: Tasks are executed when there is free time and no more pending critical or high prio tasks.
@@ -91,14 +92,14 @@ Clears every task from the queue without executing them.
 
 Executes every task in the queue, then clears the queue.
 
-### queue.start()
-
-Starts the - priority based - automatic task execution of the queue. The queue is automatically started after creation.
-
 ### queue.stop()
 
 Stops the automatic task execution of the queue.
 
+### queue.start()
+
+Starts the - priority based - automatic task execution of the queue. The queue is automatically started after creation.
+
 ### promise = queue.processing()
 
 Returns a promise, which resolves after all of the current tasks in the queue are executed. If the queue is empty, it resolves immediately.
diff --git a/scripts/test.js b/scripts/test.js
@@ -6,7 +6,7 @@ const coverage = require('rollup-plugin-coverage')
 const alias = require('rollup-plugin-alias')
 const TestServer = require('karma').Server
 
-const bundleName = process.env.BUNDLE_TYPE
+const bundleName = process.env.BUNDLE
 const bundlePath = bundleName ? `dist/${bundleName}` : 'src/index.js'
 
 const config = {
diff --git a/src/Queue.js b/src/Queue.js
@@ -1,12 +1,14 @@
-import { queues, validatePriority } from './queues'
+import { queues, priorities } from './queues'
 import { queueTaskProcessing, runTask } from './scheduling'
 
 const QUEUE = Symbol('task queue')
+const IS_STOPPED = Symbol('is stopped')
+const IS_SLEEPING = Symbol('is sleeping')
 
 export class Queue {
-  constructor (priority) {
-    this.priority = validatePriority(priority)
+  constructor (priority = priorities.SYNC) {
     this[QUEUE] = new Set()
+    this.priority = priority
     queues[this.priority].push(this[QUEUE])
   }
 
@@ -15,14 +17,18 @@ export class Queue {
   }
 
   add (task) {
-    if (typeof task !== 'function') {
-      throw new TypeError(
-        `${task} can not be added to the queue. Only functions can be added.`
-      )
+    if (this[IS_SLEEPING]) {
+      return
+    }
+    if (this.priority === priorities.SYNC && !this[IS_STOPPED]) {
+      task()
+    } else {
+      const queue = this[QUEUE]
+      queue.add(task)
+    }
+    if (!this[IS_STOPPED]) {
+      queueTaskProcessing(this.priority)
     }
-    const queue = this[QUEUE]
-    queue.add(task)
-    queueTaskProcessing(this.priority)
   }
 
   delete (task) {
@@ -31,11 +37,17 @@ export class Queue {
 
   start () {
     const queue = this[QUEUE]
-    const priorityQueues = queues[this.priority]
-    if (priorityQueues.indexOf(queue) === -1) {
-      priorityQueues.push(queue)
+    if (this.priority === priorities.SYNC) {
+      this.process()
+    } else {
+      const priorityQueues = queues[this.priority]
+      if (priorityQueues.indexOf(queue) === -1) {
+        priorityQueues.push(queue)
+      }
+      queueTaskProcessing(this.priority)
     }
-    queueTaskProcessing(this.priority)
+    this[IS_STOPPED] = false
+    this[IS_SLEEPING] = false
   }
 
   stop () {
@@ -45,6 +57,12 @@ export class Queue {
     if (index !== -1) {
       priorityQueues.splice(index, 1)
     }
+    this[IS_STOPPED] = true
+  }
+
+  sleep () {
+    this.stop()
+    this[IS_SLEEPING] = true
   }
 
   clear () {
diff --git a/src/queues.js b/src/queues.js
@@ -1,19 +1,13 @@
 export const priorities = {
-  CRITICAL: 0,
-  HIGH: 1,
-  LOW: 2
+  SYNC: 0,
+  CRITICAL: 1,
+  HIGH: 2,
+  LOW: 3
 }
-const validPriorities = new Set([0, 1, 2])
 
 export const queues = {
+  [priorities.SYNC]: [],
   [priorities.CRITICAL]: [],
   [priorities.HIGH]: [],
   [priorities.LOW]: []
 }
-
-export function validatePriority (priority) {
-  if (!validPriorities.has(priority)) {
-    throw new Error(`Invalid queue priority: ${priority}.`)
-  }
-  return priority
-}
diff --git a/src/scheduling.js b/src/scheduling.js
@@ -9,7 +9,7 @@ export function queueTaskProcessing (priority) {
     nextTick(runQueuedCriticalTasks)
   } else if (priority === priorities.HIGH) {
     nextAnimationFrame(runQueuedHighTasks)
-  } else {
+  } else if (priority === priorities.LOW) {
     nextIdlePeriod(runQueuedLowTasks)
   }
 }
diff --git a/tests/Queue.test.js b/tests/Queue.test.js
@@ -6,14 +6,6 @@ import { spy, beforeNextFrame } from './utils'
 chai.use(dirtyChai)
 
 describe('Queue', () => {
-  it('should throw on invalid priority argument', () => {
-    expect(() => new Queue()).to.throw(Error)
-    expect(() => new Queue(null)).to.throw(Error)
-    expect(() => new Queue(priorities.CRITICAL)).to.not.throw()
-    expect(() => new Queue(priorities.HIGH)).to.not.throw()
-    expect(() => new Queue(priorities.LOW)).to.not.throw()
-  })
-
   it('should auto run the added tasks', async () => {
     const queue = new Queue(priorities.CRITICAL)
     const taskSpy1 = spy(() => {})
@@ -37,19 +29,22 @@ describe('Queue', () => {
   })
 
   describe('add', () => {
-    it('should throw on non function first argument', () => {
-      const queue = new Queue(priorities.HIGH)
-      expect(() => queue.add()).to.throw(TypeError)
-      expect(() => queue.add({})).to.throw(TypeError)
-      expect(() => queue.add(null)).to.throw(TypeError)
-    })
-
     it('should add the task to the queue', () => {
       const queue = new Queue(priorities.HIGH)
-      const task = () => {}
+      const task = spy(() => {})
       expect(queue.has(task)).to.be.false()
       queue.add(task)
       expect(queue.has(task)).to.be.true()
+      expect(task.callCount).to.eql(0)
+    })
+
+    it('should run the task if it has a SYNC priority', () => {
+      const queue = new Queue(priorities.SYNC)
+      const task = spy(() => {})
+      queue.add(task)
+      expect(task.callCount).to.eql(1)
+      queue.add(task)
+      expect(task.callCount).to.eql(2)
     })
 
     it('should ignore duplicate entries', () => {
@@ -73,6 +68,16 @@ describe('Queue', () => {
       queue.delete(task)
       expect(queue.has(task)).to.be.false()
     })
+
+    it('should delete async tasks from the queue', () => {
+      const queue = new Queue(priorities.SYNC)
+      const task = () => {}
+      queue.stop()
+      queue.add(task)
+      expect(queue.has(task)).to.be.true()
+      queue.delete(task)
+      expect(queue.has(task)).to.be.false()
+    })
   })
 
   describe('size', () => {
@@ -152,10 +157,21 @@ describe('Queue', () => {
       expect(queue.size).to.eql(1)
       expect(taskSpy.callCount).to.eql(1)
     })
+
+    it('should queue tasks instead of discarding them with SYNC priority', () => {
+      const queue = new Queue(priorities.SYNC)
+      const taskSpy = spy(() => {})
+      expect(queue.size).to.eql(0)
+      queue.stop()
+      queue.add(taskSpy)
+      queue.add(taskSpy)
+      expect(queue.size).to.eql(1)
+      expect(taskSpy.callCount).to.eql(0)
+    })
   })
 
   describe('start', () => {
-    it('should start the automatic queue processing', async () => {
+    it('should start the automatic queue processing after a stop', async () => {
       const queue = new Queue(priorities.CRITICAL)
       const taskSpy = spy(() => {})
       queue.add(taskSpy)
@@ -169,6 +185,20 @@ describe('Queue', () => {
       expect(taskSpy.callCount).to.eql(1)
     })
 
+    it('should start the automatic queue processing after a sleep', async () => {
+      const queue = new Queue(priorities.CRITICAL)
+      const taskSpy = spy(() => {})
+      queue.add(taskSpy)
+      queue.sleep()
+      await beforeNextFrame()
+      expect(queue.size).to.eql(1)
+      expect(taskSpy.callCount).to.eql(0)
+      queue.start()
+      await queue.processing()
+      expect(queue.size).to.eql(0)
+      expect(taskSpy.callCount).to.eql(1)
+    })
+
     it('should should have the same effect on multiple calls', async () => {
       const queue = new Queue(priorities.CRITICAL)
       const taskSpy = spy(() => {})
@@ -184,6 +214,44 @@ describe('Queue', () => {
       expect(queue.size).to.eql(0)
       expect(taskSpy.callCount).to.eql(1)
     })
+
+    it('should process tasks with SYNC priority', async () => {
+      const queue = new Queue(priorities.SYNC)
+      const taskSpy = spy(() => {})
+      expect(queue.size).to.eql(0)
+      queue.stop()
+      queue.add(taskSpy)
+      queue.add(taskSpy)
+      await beforeNextFrame()
+      expect(queue.size).to.eql(1)
+      expect(taskSpy.callCount).to.eql(0)
+      queue.start()
+      expect(queue.size).to.eql(0)
+      expect(taskSpy.callCount).to.eql(1)
+    })
+  })
+
+  describe('sleep', () => {
+    it('should stop the automatic queue processing', async () => {
+      const queue = new Queue(priorities.CRITICAL)
+      const taskSpy = spy(() => {})
+      expect(queue.size).to.eql(0)
+      queue.add(taskSpy)
+      queue.sleep()
+      await beforeNextFrame()
+      expect(queue.size).to.eql(1)
+      expect(taskSpy.callCount).to.eql(0)
+    })
+
+    it('should discard new tasks', async () => {
+      const queue = new Queue(priorities.CRITICAL)
+      const taskSpy = spy(() => {})
+      queue.sleep()
+      queue.add(taskSpy)
+      expect(queue.size).to.eql(0)
+      await beforeNextFrame()
+      expect(taskSpy.callCount).to.eql(0)
+    })
   })
 
   describe('process', () => {

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ export function queueTaskProcessing (priority) {`
`9`	`9`	`nextTick(runQueuedCriticalTasks)`
`10`	`10`	`} else if (priority === priorities.HIGH) {`
`11`	`11`	`nextAnimationFrame(runQueuedHighTasks)`
`12`		`- } else {`
	`12`	`+ } else if (priority === priorities.LOW) {`
`13`	`13`	`nextIdlePeriod(runQueuedLowTasks)`
`14`	`14`	`}`
`15`	`15`	`}`