The way the closure serializer wraps closures in a with degrades performance by approximately 4-5x. See below for an example.

function foo() {
  with({
    a: "hello"
  }) {
    return (function() {
      return function() {
        return arguments * 10 ;
      }
    }).apply(undefined, undefined).apply(this, arguments);
  }
}


function foo2() {
  return (function() {
    return function() {
      return arguments * 10;
    }
  }).apply(undefined, undefined).apply(this, arguments)
}

for (let j = 0; j < 10; j++) {
  const start = new Date();
  for (let i = 0; i < 10*1000*1000; i++) {
    foo2(i);
  }
  
  console.log(new Date().getTime() - start.getTime());
}

From functionless/functionless#273

It would be nice to remove the deploymentOnlyModule from the bottom of all of the files. By passing in a pattern to the serialize function, we could avoiding missing files and polluting the modules.

For functionless/functionless#274

• Output import and export instead of require and exports.
• support top level async
• Generated imports should support tree shaking

Closure serialization should maintain references to closured let and var and all modifications of that value should reflect everywhere it is referenced.

Below is a test case that should pass, with expectResult: 2, but the result is 0 - because the closured let is re-declared in each closure and copied by-value, not by-ref. This is true even when using the previous with technique.

let i = 0;
function a() {
  i += 1;
}
function b() {
  i += 1;
}

cases.push({
  title: "two functions modifying a single let have changes reflected",
  func: () => {
    a();
    b();
    return i;
  },
  snapshot: true,
  expectResult: 2,
});

The repo is a fork of @pulumi/pulumi's closure serializer.

One of the changes to the original repo was to support replacement of objects to be serialized using the serialize callback.

The current implementation supports the contract (o: any) => boolean | any where:

• true - serialize o as is - original contract
• false - do not serialize o (replace with undefined) - original contract
• anything else - replace o with the value

This contract isn't great, but it was a quick update from the original contract.

We should update this to support the edge case where a boolean value should replace the original value.

Proposal:

/**
 * return the value to serialize, return `undefined` to skip serialization. `undefined` may also be used to avoid circular references.
 **/
serialize: (o: any) => any | undefined

In the updated contract, the user just returns the new value or current value.

Add a README and be sure to mention that this is a fork.

It should be possible to transform the AST syntax prior to serialization rather than relying purely on value-level serialization customization.

This would be useful for removing syntax added by Functionless's TS transformers.