Module runtime/closure

@pulumi/pulumi > runtime > closure

const getFunctionLocationAsync

const getFunctionLocationAsync: getFunctionLocationAsync =  versionSpecificV8Module.getFunctionLocationAsync;

Given a function, returns the file, line and column number in the file where this function was defined. Returns { “”, 0, 0 } if the location cannot be found or if the given function has no Script.

const lookupCapturedVariableValueAsync

const lookupCapturedVariableValueAsync: lookupCapturedVariableValueAsync =  versionSpecificV8Module.lookupCapturedVariableValueAsync;

Given a function and a free variable name, lookupCapturedVariableValue looks up the value of that free variable in the scope chain of the provided function. If the free variable is not found, throwOnFailure indicates whether or not this function should throw or return `undefined.

function createFunctionInfoAsync

createFunctionInfoAsync(func: Function, serialize: (o: any) => boolean, logResource: resource.Resource | undefined): Promise<FunctionInfo>

createFunctionInfo serializes a function and its closure environment into a form that is amenable to persistence as simple JSON. Like toString, it includes the full text of the function’s source code, suitable for execution. Unlike toString, it actually includes information about the captured environment.

function parseFunction

parseFunction(funcString: string): [, string, ParsedFunction]

function rewriteSuperReferences

rewriteSuperReferences(code: string, isStatic: boolean): string

function serializeFunction

serializeFunction(func: Function, args: SerializeFunctionArgs): Promise<SerializedFunction>

serializeFunction serializes a JavaScript function into a text form that can be loaded in another execution context, for example as part of a function callback associated with an AWS Lambda. The function serialization captures any variables captured by the function body and serializes those values into the generated text along with the function body. This process is recursive, so that functions referenced by the body of the serialized function will themselves be serialized as well. This process also deeply serializes captured object values, including prototype chains and property descriptors, such that the semantics of the function when deserialized should match the original function.

There are several known limitations:

  • If a native function is captured either directly or indirectly, closure serialization will return an error.
  • Captured values will be serialized based on their values at the time that serializeFunction is called. Mutations to these values after that (but before the deserialized function is used) will not be observed by the deserialized function.

function serializeFunctionAsync

serializeFunctionAsync(func: Function, serialize?: undefined | (o: any) => boolean): Promise<string>

interface CapturedPropertyChain

interface CapturedPropertyInfo

interface CapturedVariables

interface Entry

Entry is the environment slot for a named lexically captured variable.

property array

array?: Entry[];

property expr

expr?: undefined | string;

property function

function?: FunctionInfo;

property json

json?: any;

property module

module?: undefined | string;

property object

object?: ObjectInfo;

property output

output?: Entry;

property promise

promise?: Entry;

property regexp

regexp?: undefined | {
    flags: string;
    source: string;
};

interface FunctionInfo

interface ObjectInfo

interface ParsedFunction

interface ParsedFunctionCode

property funcExprWithName

funcExprWithName?: undefined | string;

property funcExprWithoutName

funcExprWithoutName: string;

property functionDeclarationName

functionDeclarationName?: undefined | string;

property isArrowFunction

isArrowFunction: boolean;

interface PropertyInfo

property configurable

configurable?: undefined | false | true;

property enumerable

enumerable?: undefined | false | true;

property get

get?: Entry;

property hasValue

hasValue: boolean;

property set

set?: Entry;

property writable

writable?: undefined | false | true;

interface PropertyInfoAndValue

interface PropertyMap

extends Map<Entry, PropertyInfoAndValue>

method __@iterator

__@iterator(): IterableIterator<[, Entry, PropertyInfoAndValue]>

Returns an iterable of entries in the map.

method clear

clear(): void

method delete

delete(key: Entry): boolean

method entries

entries(): IterableIterator<[, Entry, PropertyInfoAndValue]>

Returns an iterable of key, value pairs for every entry in the map.

method forEach

forEach(callbackfn: (value: PropertyInfoAndValue, key: Entry, map: Map<Entry, PropertyInfoAndValue>) => void, thisArg?: any): void

method get

method has

has(key: Entry): boolean

method keys

keys(): IterableIterator<Entry>

Returns an iterable of keys in the map

method set

set(key: Entry, value: PropertyInfoAndValue): this

method values

values(): IterableIterator<PropertyInfoAndValue>

Returns an iterable of values in the map

property Map

Map: MapConstructor;

property __@toStringTag

__@toStringTag: string;

property size

size: number;

interface SerializeFunctionArgs

SerializeFunctionArgs are arguments used to serialize a JavaScript function

property exportName

exportName?: undefined | string;

The name to export from the module defined by the generated module text. Defaults to ‘handler’.

property isFactoryFunction

isFactoryFunction?: undefined | false | true;

If this is a function which, when invoked, will produce the actual entrypoint function. Useful for when serializing a function that has high startup cost that only wants to be run once. The signature of this function should be: () => (provider_handler_args…) => provider_result

This will then be emitted as: exports.[exportName] = serialized_func_name();

In other words, the function will be invoked (once) and the resulting inner function will be what is exported.

property logResource

logResource?: Resource;

The resource to log any errors we encounter against.

property serialize

serialize?: undefined | (o: any) => boolean;

A function to prevent serialization of certain objects captured during the serialization. Primarily used to prevent potential cycles.

interface SerializedFunction

SerializeFunction is a representation of a serialized JavaScript function.

property exportName

exportName: string;

The name of the exported module member.

property text

text: string;

The text of a JavaScript module which exports a single name bound to an appropriate value. In the case of a normal function, this value will just be serialized function. In the case of a factory function this value will be the result of invoking the factory function.

type CapturedVariableMap

type CapturedVariableMap = Map<string, CapturedPropertyChain[]>;