make-synchronized

Make synchronized functions.

Install

yarn add make-synchronized

Usage

This module mainly to support two kinds of different purpose of usage:

1. Make a module that turns asynchronous function into synchronized

   import makeSynchronized from 'make-synchronized'
   
   export default makeSynchronized(import.meta, myAsynchronousFunction)

2. Make asynchronous functions in an existing module into synchronized

   import makeSynchronized from 'make-synchronized'
   
   const synchronized = makeSynchronized(
     new URL('./my-asynchronous-function-module.js', import.meta.url),
   )

Named exports

import {
  makeSynchronized, // Same as the default export
  makeDefaultExportSynchronized,
  makeModuleSynchronized,
  makeSynchronizedFunction,
  makeSynchronizedFunctions,
} from 'make-synchronized'

Limitation

This module uses MessagePort#postMessage to transfer arguments, return values, errors between the main thread and the worker. Please make sure the arguments and return values are serializable by the structured clone algorithm.

API

makeSynchronized(module, implementation)

Make asynchronous functions to be synchronized for export.

• If implementation is a function, returns a synchronized version of the passed function.

  Note: It MUST be used as the default export

  // foo.js
  import makeSynchronized from 'make-synchronized'
  
  export default makeSynchronized(import.meta, () => Promise.resolve('foo'))

  import foo from './foo.js'
  
  foo()
  // -> foo

  • Example

• If implementation is a object with multiple functions, returns a Proxy object with synchronized functions attached.

  Note: Functions MUST exported as the same name as the key in implementation object.

  // foo-and-bar.js
  import makeSynchronized from 'make-synchronized'
  
  export const {foo, bar} = makeSynchronized(import.meta, {
    async foo() {
      return 'foo'
    },
    async bar() {
      return 'bar'
    },
  })

  import {foo, bar} from './foo-and-bar.js'
  
  foo()
  // -> foo
  
  bar()
  // -> bar

• Example

makeSynchronized(module)

Make asynchronous functions in an existing module to be synchronized to call.

• If the passing module is a module that contains a function type default export, returns a Proxy function, with other specifiers attached.

  // foo.js
  export default () => Promise.resolve('default export called')
  export const foo = 'foo'
  export const bar = () => Promise.resolve('bar called')

  const synchronized = makeSynchronized(new URL('./foo.js', import.meta.url))
  
  synchronized()
  // -> "default export called"
  
  synchronized.foo
  // -> "foo"
  
  // This function also synchronized.
  synchronized.bar()
  // -> "bar called"

  Example

• If the passing module is a module without default export or default export is not a function, a Module object will be returned with all specifiers.

  // foo.js
  export const foo = 'foo'
  export const bar = () => Promise.resolve('bar called')

  import makeSynchronized from 'make-synchronized'
  
  const module = makeSynchronized(new URL('./foo.js', import.meta.url))
  
  module
  // [Object: null prototype] [Module] { bar: [Getter], foo: [Getter] }
  
  module.foo
  // -> "foo"
  
  module.bar()
  // -> "bar called"

  Example

makeSynchronizedFunction(module, implementation, specifier?)

Make a synchronized function for export.

Explicit version of makeSynchronized(module, implementation) that returns the synchronized function for export.

import {makeSynchronizedFunction} from 'make-synchronized'

export default makeSynchronizedFunction(
  import.meta,
  async () => 'default export called',
)
export const foo = makeSynchronizedFunction(
  import.meta,
  async () => 'foo export called',
  'foo',
)

makeSynchronizedFunctions(module, implementation)

Make synchronized functions for export.

Explicit version of makeSynchronized(module, implementation) that only returns Proxy with synchronized functions for export.

import {makeSynchronizedFunctions} from 'make-synchronized'

export const {
  // MUST match the key in second argument
  foo,
  bar,
} = makeSynchronizedFunctions(import.meta, {
  foo: async () => 'foo export called',
  bar: async () => 'bar export called',
})

makeDefaultExportSynchronized(module)

Make an existing module's default export to be a synchronized function.

Explicit version of makeSynchronized(module) that only returns the synchronized default export.

import {makeDefaultExportSynchronized} from 'make-synchronized'

const foo = makeModuleSynchronized('foo')

foo()
// -> default export of `foo` module is called.

makeModuleSynchronized(module)

Make an existing module's exports to be synchronized functions.

Synchronize version of import(module), always returns a Module.

- const {default: foo} = await import('foo')
+ const {default: foo} = makeModuleSynchronized('foo')

import {makeModuleSynchronized} from 'make-synchronized'

const {default: foo, bar} = makeModuleSynchronized('foo')

foo()
// -> default export of `foo` module is called.

bar()
// -> `bar` function from `foo` module is called.