@netlify/zip-it-and-ship-it 4.23.3 → 4.23.5-setup-typescript-4

package/dist/node_dependencies/published.js

@@ -0,0 +1,42 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { promisify } = require('util');
+const glob = require('glob');
+const pGlob = promisify(glob);
+// We use all the files published by the Node.js except some that are not needed
+const getPublishedFiles = function (modulePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ignore = getIgnoredFiles(modulePath);
+        const publishedFiles = yield pGlob(`${modulePath}/**`, {
+            ignore,
+            nodir: true,
+            absolute: true,
+            dot: true,
+        });
+        return publishedFiles;
+    });
+};
+const getIgnoredFiles = function (modulePath) {
+    return IGNORED_FILES.map((ignoreFile) => `${modulePath}/${ignoreFile}`);
+};
+// To make the zip archive smaller, we remove those.
+const IGNORED_FILES = [
+    'node_modules/**',
+    '.npmignore',
+    'package-lock.json',
+    'yarn.lock',
+    '*.log',
+    '*.lock',
+    '*~',
+    '*.map',
+    '*.ts',
+    '*.patch',
+];
+module.exports = { getPublishedFiles };

package/dist/node_dependencies/resolve.d.ts

@@ -0,0 +1,2 @@
+export function resolvePackage(moduleName: any, baseDirs: any): Promise<any>;
+export function resolvePathPreserveSymlinks(path: any, baseDirs: any): Promise<any>;

package/dist/node_dependencies/resolve.js

@@ -0,0 +1,114 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { version: nodeVersion } = require('process');
+const findUp = require('find-up');
+const pathExists = require('path-exists');
+const resolveLib = require('resolve');
+const { lt: ltVersion } = require('semver');
+const BACKSLASH_REGEXP = /\\/g;
+// Find the path to a module's `package.json`
+// We need to use `resolve` instead of `require.resolve()` because:
+//  - it is async
+//  - it preserves symlinks:
+//     - this is important because if a file does a `require('./symlink')`, we
+//       need to bundle the symlink and its target, not only the target
+//     - `path.resolve()` cannot be used for relative|absolute file paths
+//       because it does not resolve ommitted file extension,
+//       e.g. `require('./file')` instead of `require('./file.js')`
+//     - the CLI flag `--preserve-symlinks` can be used with Node.js, but it
+//       cannot be set runtime
+// However it does not give helpful error messages.
+//   https://github.com/browserify/resolve/issues/223
+// So, on errors, we fallback to `require.resolve()`
+const resolvePackage = function (moduleName, baseDirs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield resolvePathPreserveSymlinks(`${moduleName}/package.json`, baseDirs);
+        }
+        catch (error) {
+            if (ltVersion(nodeVersion, REQUEST_RESOLVE_MIN_VERSION)) {
+                throw error;
+            }
+            try {
+                return resolvePathFollowSymlinks(`${moduleName}/package.json`, baseDirs);
+            }
+            catch (error_) {
+                return yield resolvePackageFallback(moduleName, baseDirs, error_);
+            }
+        }
+    });
+};
+// TODO: remove after dropping support for Node <8.9.0
+// `require.resolve()` option `paths` was introduced in Node 8.9.0
+const REQUEST_RESOLVE_MIN_VERSION = '8.9.0';
+// We need to use `new Promise()` due to a bug with `utils.promisify()` on
+// `resolve`:
+//   https://github.com/browserify/resolve/issues/151#issuecomment-368210310
+const resolvePathPreserveSymlinksForDir = function (path, basedir) {
+    return new Promise((resolve, reject) => {
+        // eslint-disable-next-line promise/prefer-await-to-callbacks
+        resolveLib(path, { basedir, preserveSymlinks: true }, (error, resolvedLocation) => {
+            if (error) {
+                return reject(error);
+            }
+            resolve(resolvedLocation);
+        });
+    });
+};
+// the resolve library has a `paths` option but it's not the same as multiple basedirs
+// see https://github.com/browserify/resolve/issues/188#issuecomment-679010477
+// we return the first resolved location or the first error if all failed
+const resolvePathPreserveSymlinks = function (path, baseDirs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let firstError;
+        for (const basedir of baseDirs) {
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                return yield resolvePathPreserveSymlinksForDir(path, basedir);
+            }
+            catch (error) {
+                firstError = firstError || error;
+            }
+        }
+        throw firstError;
+    });
+};
+const resolvePathFollowSymlinks = function (path, baseDirs) {
+    return require.resolve(path, { paths: baseDirs });
+};
+// `require.resolve()` on a module's specific file (like `package.json`)
+// can be forbidden by the package author by using an `exports` field in
+// their `package.json`. We need this fallback.
+// It looks for the first directory up from a package's `main` file that:
+//   - is named like the package
+//   - has a `package.json`
+// Theoretically, this might not the root `package.json`, but this is very
+// unlikely, and we don't have any better alternative.
+const resolvePackageFallback = function (moduleName, baseDirs, error) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mainFilePath = resolvePathFollowSymlinks(moduleName, baseDirs);
+        const packagePath = yield findUp(isPackageDir.bind(null, moduleName), { cwd: mainFilePath, type: 'directory' });
+        if (packagePath === undefined) {
+            throw error;
+        }
+        return packagePath;
+    });
+};
+const isPackageDir = function (moduleName, dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Need to use `endsWith()` to take into account `@scope/package`.
+        // Backslashes need to be converted for Windows.
+        if (!dir.replace(BACKSLASH_REGEXP, '/').endsWith(moduleName) || !(yield pathExists(`${dir}/package.json`))) {
+            return;
+        }
+        return dir;
+    });
+};
+module.exports = { resolvePackage, resolvePathPreserveSymlinks };

package/dist/node_dependencies/side_files.d.ts

@@ -0,0 +1 @@
+export function getSideFiles(modulePath: any, moduleName: any): any[] | Promise<string[]>;

package/dist/node_dependencies/side_files.js

@@ -0,0 +1,14 @@
+const { getPublishedFiles } = require('./published');
+// Some modules generate source files on `postinstall` that are not located
+// inside the module's directory itself.
+const getSideFiles = function (modulePath, moduleName) {
+    const sideFiles = SIDE_FILES[moduleName];
+    if (sideFiles === undefined) {
+        return [];
+    }
+    return getPublishedFiles(`${modulePath}/${sideFiles}`);
+};
+const SIDE_FILES = {
+    '@prisma/client': '../../.prisma',
+};
+module.exports = { getSideFiles };

package/dist/node_dependencies/special_cases.d.ts

@@ -0,0 +1,6 @@
+export function getExternalAndIgnoredModulesFromSpecialCases({ srcDir }: {
+    srcDir: any;
+}): Promise<{
+    externalModules: string[];
+    ignoredModules: any[];
+}>;

package/dist/node_dependencies/special_cases.js

@@ -0,0 +1,44 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { getPackageJson } = require('./package_json');
+const EXTERNAL_MODULES = ['@prisma/client'];
+const IGNORED_MODULES = ['aws-sdk'];
+const getPackageJsonIfAvailable = (srcDir) => __awaiter(this, void 0, void 0, function* () {
+    try {
+        const packageJson = yield getPackageJson(srcDir);
+        return packageJson;
+    }
+    catch (_) {
+        return {};
+    }
+});
+const getModulesForNextJs = ({ dependencies, devDependencies }) => {
+    const allDependencies = Object.assign(Object.assign({}, dependencies), devDependencies);
+    const externalModules = allDependencies.next ? ['critters', 'nanoid'] : [];
+    const ignoredModules = [];
+    return {
+        externalModules,
+        ignoredModules,
+    };
+};
+const getExternalAndIgnoredModulesFromSpecialCases = ({ srcDir }) => __awaiter(this, void 0, void 0, function* () {
+    const { dependencies = {}, devDependencies = {} } = yield getPackageJsonIfAvailable(srcDir);
+    const { externalModules: nextJsExternalModules, ignoredModules: nextJsIgnoredModules } = getModulesForNextJs({
+        dependencies,
+        devDependencies,
+    });
+    const externalModules = [...EXTERNAL_MODULES, ...nextJsExternalModules];
+    const ignoredModules = [...IGNORED_MODULES, ...nextJsIgnoredModules];
+    return {
+        externalModules,
+        ignoredModules,
+    };
+});
+module.exports = { getExternalAndIgnoredModulesFromSpecialCases };

package/dist/node_dependencies/traverse.d.ts

@@ -0,0 +1,39 @@
+export function getDependencyPathsForDependency({ dependency, basedir, state, packageJson, pluginsModulesPath, }: {
+    dependency: any;
+    basedir: any;
+    state: any;
+    packageJson: any;
+    pluginsModulesPath: any;
+}): any;
+export function getDependencyNamesAndPathsForDependencies({ dependencies: dependencyNames, basedir, state, pluginsModulesPath, }: {
+    dependencies: any;
+    basedir: any;
+    state?: {
+        localFiles: Set<any>;
+        moduleNames: Set<any>;
+        modulePaths: Set<any>;
+    };
+    pluginsModulesPath: any;
+}): Promise<{
+    moduleNames: any[];
+    paths: any[];
+}>;
+export function getDependencyNamesAndPathsForDependency({ dependency, basedir, state, packageJson, pluginsModulesPath, }: {
+    dependency: any;
+    basedir: any;
+    state?: {
+        localFiles: Set<any>;
+        moduleNames: Set<any>;
+        modulePaths: Set<any>;
+    };
+    packageJson: any;
+    pluginsModulesPath: any;
+}): Promise<{
+    moduleNames: any[];
+    paths: any;
+}>;
+export function getNewCache(): {
+    localFiles: Set<any>;
+    moduleNames: Set<any>;
+    modulePaths: Set<any>;
+};

package/dist/node_dependencies/traverse.js

@@ -0,0 +1,120 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { dirname } = require('path');
+const { getModuleName } = require('./module');
+const { getNestedDependencies, handleModuleNotFound } = require('./nested');
+const { getPackageJson } = require('./package_json');
+const { getPublishedFiles } = require('./published');
+const { resolvePackage } = require('./resolve');
+const { getSideFiles } = require('./side_files');
+const EXCLUDED_MODULES = new Set(['aws-sdk']);
+// Local cache used for optimizing the traversal of module dependencies.
+const getNewCache = () => ({ localFiles: new Set(), moduleNames: new Set(), modulePaths: new Set() });
+// When a file requires a module, we find its path inside `node_modules` and
+// use all its published files. We also recurse on the module's dependencies.
+const getDependencyPathsForDependency = function ({ dependency, basedir, state, packageJson, pluginsModulesPath, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const moduleName = getModuleName(dependency);
+        // Happens when doing require("@scope") (not "@scope/name") or other oddities
+        // Ignore those.
+        if (moduleName === null) {
+            return [];
+        }
+        try {
+            return yield getDependenciesForModuleName({ moduleName, basedir, state, pluginsModulesPath });
+        }
+        catch (error) {
+            return handleModuleNotFound({ error, moduleName, packageJson });
+        }
+    });
+};
+const getDependencyNamesAndPathsForDependencies = function ({ dependencies: dependencyNames, basedir, state = getNewCache(), pluginsModulesPath, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const packageJson = yield getPackageJson(basedir);
+        const dependencies = yield Promise.all(dependencyNames.map((dependencyName) => getDependencyNamesAndPathsForDependency({
+            dependency: dependencyName,
+            basedir,
+            state,
+            packageJson,
+            pluginsModulesPath,
+        })));
+        const moduleNames = new Set(dependencies.flatMap((dependency) => [...dependency.moduleNames]));
+        const paths = new Set(dependencies.flatMap((dependency) => [...dependency.paths]));
+        return {
+            moduleNames: [...moduleNames],
+            paths: [...paths],
+        };
+    });
+};
+const getDependencyNamesAndPathsForDependency = function ({ dependency, basedir, state = getNewCache(), packageJson, pluginsModulesPath, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const paths = yield getDependencyPathsForDependency({ dependency, basedir, state, packageJson, pluginsModulesPath });
+            return {
+                moduleNames: [...state.moduleNames],
+                paths,
+            };
+        }
+        catch (error) {
+            if (error.code === 'MODULE_NOT_FOUND') {
+                return {
+                    moduleNames: [],
+                    paths: [],
+                };
+            }
+            throw error;
+        }
+    });
+};
+const getDependenciesForModuleName = function ({ moduleName, basedir, state, pluginsModulesPath }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (isExcludedModule(moduleName)) {
+            return [];
+        }
+        // Find the Node.js module directory path
+        const packagePath = yield resolvePackage(moduleName, [basedir, pluginsModulesPath].filter(Boolean));
+        if (packagePath === undefined) {
+            return [];
+        }
+        const modulePath = dirname(packagePath);
+        if (state.modulePaths.has(modulePath)) {
+            return [];
+        }
+        state.moduleNames.add(moduleName);
+        state.modulePaths.add(modulePath);
+        // The path depends on the user's build, i.e. must be dynamic
+        // eslint-disable-next-line import/no-dynamic-require, node/global-require
+        const packageJson = require(packagePath);
+        const [publishedFiles, sideFiles, depsPaths] = yield Promise.all([
+            getPublishedFiles(modulePath),
+            getSideFiles(modulePath, moduleName),
+            getNestedModules({ modulePath, state, packageJson, pluginsModulesPath }),
+        ]);
+        return [...publishedFiles, ...sideFiles, ...depsPaths];
+    });
+};
+const isExcludedModule = function (moduleName) {
+    return EXCLUDED_MODULES.has(moduleName) || moduleName.startsWith('@types/');
+};
+const getNestedModules = function ({ modulePath, state, packageJson, pluginsModulesPath }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const dependencies = getNestedDependencies(packageJson);
+        const depsPaths = yield Promise.all(dependencies.map((dependency) => getDependencyPathsForDependency({ dependency, basedir: modulePath, state, packageJson, pluginsModulesPath })));
+        // TODO: switch to Array.flat() once we drop support for Node.js < 11.0.0
+        // eslint-disable-next-line unicorn/prefer-spread
+        return [].concat(...depsPaths);
+    });
+};
+module.exports = {
+    getDependencyPathsForDependency,
+    getDependencyNamesAndPathsForDependencies,
+    getDependencyNamesAndPathsForDependency,
+    getNewCache,
+};

package/dist/node_dependencies/tree_files.d.ts

@@ -0,0 +1,3 @@
+import { Stats } from 'fs';
+declare const getTreeFiles: (srcPath: string, stat: Stats) => Promise<string[]>;
+export { getTreeFiles };

package/dist/node_dependencies/tree_files.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTreeFiles = void 0;
+const util_1 = require("util");
+const glob_1 = __importDefault(require("glob"));
+const pGlob = (0, util_1.promisify)(glob_1.default);
+// When using a directory, we include all its descendants except `node_modules`
+const getTreeFiles = function (srcPath, stat) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!stat.isDirectory()) {
+            return [srcPath];
+        }
+        return yield pGlob(`${srcPath}/**`, {
+            ignore: `${srcPath}/**/node_modules/**`,
+            nodir: true,
+            absolute: true,
+        });
+    });
+};
+exports.getTreeFiles = getTreeFiles;

package/dist/node_dependencies/tree_shake.d.ts

@@ -0,0 +1 @@
+export function shouldTreeShake(dependency: any, treeShakeNext: any): boolean;

package/{src → dist}/node_dependencies/tree_shake.js

@@ -1,18 +1,14 @@
-const { getModuleName } = require('./module')
-
-const LOCAL_IMPORT_REGEXP = /^(\.|\/)/
-
+const { getModuleName } = require('./module');
+const LOCAL_IMPORT_REGEXP = /^(\.|\/)/;
 // we tree shake direct local requires to bundle only relevant code
 // we don't tree shake external dependencies since they can break our tree shaking logic by:
 // 1. doing dynamic requires (e.g. require(dynamicPath))
 // 2. reading files (e.g. fs.readFileSync(someNonJsFile))
 // an exception is when the function was generated by `next-on-netlify` to avoid bundling the entire `Next.js` framework
 const shouldTreeShake = function (dependency, treeShakeNext) {
-  if (LOCAL_IMPORT_REGEXP.test(dependency)) {
-    return true
-  }
-
-  return treeShakeNext && getModuleName(dependency) === 'next'
-}
-
-module.exports = { shouldTreeShake }
+    if (LOCAL_IMPORT_REGEXP.test(dependency)) {
+        return true;
+    }
+    return treeShakeNext && getModuleName(dependency) === 'next';
+};
+module.exports = { shouldTreeShake };

package/dist/runtimes/detect_runtime.d.ts

@@ -0,0 +1,4 @@
+export function detectBinaryRuntime({ fsCache, path }: {
+    fsCache: any;
+    path: any;
+}): Promise<string>;

package/dist/runtimes/detect_runtime.js

@@ -0,0 +1,27 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { detect, Runtime } = require('elf-cam');
+const { RUNTIME_GO, RUNTIME_RUST } = require('../utils/consts');
+const { cachedReadFile } = require('../utils/fs');
+// Try to guess the runtime by inspecting the binary file.
+const detectBinaryRuntime = function ({ fsCache, path }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const buffer = yield cachedReadFile(fsCache, path);
+            return RUNTIMES[detect(buffer)];
+        }
+        catch (error) { }
+    });
+};
+const RUNTIMES = {
+    [Runtime.Go]: RUNTIME_GO,
+    [Runtime.Rust]: RUNTIME_RUST,
+};
+module.exports = { detectBinaryRuntime };

package/dist/runtimes/go/builder.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+export function build({ destPath, mainFile, srcDir }: {
+    destPath: any;
+    mainFile: any;
+    srcDir: any;
+}): Promise<{
+    mainFile: any;
+    name: string;
+    srcDir: any;
+    srcPath: any;
+    stat: import("fs").Stats;
+}>;

package/dist/runtimes/go/builder.js

@@ -0,0 +1,39 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { basename } = require('path');
+const { RUNTIME_GO } = require('../../utils/consts');
+const { lstat } = require('../../utils/fs');
+const { runCommand } = require('../../utils/shell');
+const build = ({ destPath, mainFile, srcDir }) => __awaiter(this, void 0, void 0, function* () {
+    const functionName = basename(srcDir);
+    try {
+        yield runCommand('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
+            cwd: srcDir,
+            env: {
+                CGO_ENABLED: '0',
+                GOOS: 'linux',
+            },
+        });
+    }
+    catch (error) {
+        error.customErrorInfo = { type: 'functionsBundling', location: { functionName, runtime: RUNTIME_GO } };
+        console.error(`Could not compile Go function ${functionName}:\n`);
+        throw error;
+    }
+    const stat = yield lstat(destPath);
+    return {
+        mainFile,
+        name: functionName,
+        srcDir,
+        srcPath: destPath,
+        stat,
+    };
+});
+module.exports = { build };

package/dist/runtimes/go/index.d.ts

@@ -0,0 +1,18 @@
+export function findFunctionsInPaths({ featureFlags, fsCache, paths }: {
+    featureFlags: any;
+    fsCache: any;
+    paths: any;
+}): Promise<any[]>;
+import { RUNTIME_GO } from "../../utils/consts";
+export function zipFunction({ config, destFolder, filename, mainFile, srcDir, srcPath }: {
+    config: any;
+    destFolder: any;
+    filename: any;
+    mainFile: any;
+    srcDir: any;
+    srcPath: any;
+}): Promise<{
+    config: any;
+    path: string;
+}>;
+export { RUNTIME_GO as name };

package/dist/runtimes/go/index.js

@@ -0,0 +1,78 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { basename, dirname, extname, join } = require('path');
+const cpFile = require('cp-file');
+const { RUNTIME_GO } = require('../../utils/consts');
+const { cachedLstat, cachedReaddir } = require('../../utils/fs');
+const { detectBinaryRuntime } = require('../detect_runtime');
+const { build } = require('./builder');
+const detectGoFunction = ({ fsCache, path }) => __awaiter(this, void 0, void 0, function* () {
+    const stat = yield cachedLstat(fsCache, path);
+    if (!stat.isDirectory()) {
+        return;
+    }
+    const directoryName = basename(path);
+    const files = yield cachedReaddir(fsCache, path);
+    const mainFileName = [`${directoryName}.go`, 'main.go'].find((name) => files.includes(name));
+    if (mainFileName === undefined) {
+        return;
+    }
+    return mainFileName;
+});
+const findFunctionsInPaths = function ({ featureFlags, fsCache, paths }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const functions = yield Promise.all(paths.map((path) => __awaiter(this, void 0, void 0, function* () {
+            const runtime = yield detectBinaryRuntime({ fsCache, path });
+            if (runtime === RUNTIME_GO) {
+                return processBinary({ fsCache, path });
+            }
+            if (featureFlags.buildGoSource !== true) {
+                return;
+            }
+            const goSourceFile = yield detectGoFunction({ fsCache, path });
+            if (goSourceFile) {
+                return processSource({ fsCache, mainFile: goSourceFile, path });
+            }
+        })));
+        return functions.filter(Boolean);
+    });
+};
+const processBinary = ({ fsCache, path }) => __awaiter(this, void 0, void 0, function* () {
+    const stat = yield cachedLstat(fsCache, path);
+    const name = basename(path, extname(path));
+    return {
+        mainFile: path,
+        name,
+        srcDir: dirname(path),
+        srcPath: path,
+        stat,
+    };
+});
+const processSource = ({ mainFile, path }) => {
+    const functionName = basename(path);
+    return {
+        mainFile: join(path, mainFile),
+        name: functionName,
+        srcDir: path,
+        srcPath: path,
+    };
+};
+const zipFunction = function ({ config, destFolder, filename, mainFile, srcDir, srcPath }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const destPath = join(destFolder, filename);
+        const isSource = extname(mainFile) === '.go';
+        // If we're building a Go function from source, we call the build method and
+        // it'll take care of placing the binary in the right location. If not, we
+        // need to copy the existing binary file to the destination directory.
+        yield (isSource ? build({ destPath, mainFile, srcDir }) : cpFile(srcPath, destPath));
+        return { config, path: destPath };
+    });
+};
+module.exports = { findFunctionsInPaths, name: RUNTIME_GO, zipFunction };

package/dist/runtimes/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Gets a list of functions found in a list of paths.
+ *
+ * @param   {Object} config
+ * @param   {Boolean} dedupe
+ * @param   {String} path
+ * @returns {Promise<Map>}
+ */
+export function getFunctionsFromPaths(paths: any, { config, dedupe, featureFlags }?: boolean): Promise<Map<any, any>>;