@aws-cdk-testing/cli-integ 2.61.0

package/lib/memoize.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoize0 = void 0;
+/**
+ * Return a memoized version of an function with 0 arguments.
+ *
+ * Async-safe.
+ */
+function memoize0(fn) {
+    let promise;
+    return () => {
+        if (!promise) {
+            promise = fn();
+        }
+        return promise;
+    };
+}
+exports.memoize0 = memoize0;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVtb2l6ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm1lbW9pemUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7Ozs7R0FJRztBQUNILFNBQWdCLFFBQVEsQ0FBSSxFQUFvQjtJQUM5QyxJQUFJLE9BQStCLENBQUM7SUFDcEMsT0FBTyxHQUFHLEVBQUU7UUFDVixJQUFJLENBQUMsT0FBTyxFQUFFO1lBQ1osT0FBTyxHQUFHLEVBQUUsRUFBRSxDQUFDO1NBQ2hCO1FBQ0QsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQyxDQUFDO0FBQ0osQ0FBQztBQVJELDRCQVFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBSZXR1cm4gYSBtZW1vaXplZCB2ZXJzaW9uIG9mIGFuIGZ1bmN0aW9uIHdpdGggMCBhcmd1bWVudHMuXG4gKlxuICogQXN5bmMtc2FmZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG1lbW9pemUwPEE+KGZuOiAoKSA9PiBQcm9taXNlPEE+KTogKCkgPT4gUHJvbWlzZTxBPiB7XG4gIGxldCBwcm9taXNlOiBQcm9taXNlPEE+IHwgdW5kZWZpbmVkO1xuICByZXR1cm4gKCkgPT4ge1xuICAgIGlmICghcHJvbWlzZSkge1xuICAgICAgcHJvbWlzZSA9IGZuKCk7XG4gICAgfVxuICAgIHJldHVybiBwcm9taXNlO1xuICB9O1xufSJdfQ==

package/lib/npm.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Use NPM preinstalled on the machine to look up a list of TypeScript versions
+ */
+export declare function typescriptVersionsSync(): string[];

package/lib/npm.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescriptVersionsSync = void 0;
+const child_process_1 = require("child_process");
+const MINIMUM_VERSION = '3.9';
+/**
+ * Use NPM preinstalled on the machine to look up a list of TypeScript versions
+ */
+function typescriptVersionsSync() {
+    const { stdout } = child_process_1.spawnSync('npm', ['--silent', 'view', `typescript@>=${MINIMUM_VERSION}`, 'version', '--json']);
+    const versions = JSON.parse(stdout);
+    return Array.from(new Set(versions.map(v => v.split('.').slice(0, 2).join('.'))));
+}
+exports.typescriptVersionsSync = typescriptVersionsSync;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnBtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsibnBtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLGlEQUEwQztBQUUxQyxNQUFNLGVBQWUsR0FBRyxLQUFLLENBQUM7QUFFOUI7O0dBRUc7QUFDSCxTQUFnQixzQkFBc0I7SUFDcEMsTUFBTSxFQUFFLE1BQU0sRUFBRSxHQUFHLHlCQUFTLENBQUMsS0FBSyxFQUFFLENBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSxnQkFBZ0IsZUFBZSxFQUFFLEVBQUUsU0FBUyxFQUFFLFFBQVEsQ0FBQyxDQUFDLENBQUM7SUFFbEgsTUFBTSxRQUFRLEdBQWEsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUM5QyxPQUFPLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxHQUFHLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDcEYsQ0FBQztBQUxELHdEQUtDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgc3Bhd25TeW5jIH0gZnJvbSAnY2hpbGRfcHJvY2Vzcyc7XG5cbmNvbnN0IE1JTklNVU1fVkVSU0lPTiA9ICczLjknO1xuXG4vKipcbiAqIFVzZSBOUE0gcHJlaW5zdGFsbGVkIG9uIHRoZSBtYWNoaW5lIHRvIGxvb2sgdXAgYSBsaXN0IG9mIFR5cGVTY3JpcHQgdmVyc2lvbnNcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHR5cGVzY3JpcHRWZXJzaW9uc1N5bmMoKTogc3RyaW5nW10ge1xuICBjb25zdCB7IHN0ZG91dCB9ID0gc3Bhd25TeW5jKCducG0nLCBbJy0tc2lsZW50JywgJ3ZpZXcnLCBgdHlwZXNjcmlwdEA+PSR7TUlOSU1VTV9WRVJTSU9OfWAsICd2ZXJzaW9uJywgJy0tanNvbiddKTtcblxuICBjb25zdCB2ZXJzaW9uczogc3RyaW5nW10gPSBKU09OLnBhcnNlKHN0ZG91dCk7XG4gIHJldHVybiBBcnJheS5mcm9tKG5ldyBTZXQodmVyc2lvbnMubWFwKHYgPT4gdi5zcGxpdCgnLicpLnNsaWNlKDAsIDIpLmpvaW4oJy4nKSkpKTtcbn0iXX0=

package/lib/package-sources/release-source.d.ts

@@ -0,0 +1,22 @@
+import { IPackageSourceSetup, IPackageSource } from './source';
+export declare class ReleasePackageSourceSetup implements IPackageSourceSetup {
+    private readonly version;
+    private readonly frameworkVersion?;
+    readonly name = "release";
+    readonly description: string;
+    private tempDir?;
+    constructor(version: string, frameworkVersion?: string | undefined);
+    prepare(): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export declare class ReleasePackageSource implements IPackageSource {
+    private readonly cliPath;
+    private readonly version;
+    constructor();
+    makeCliAvailable(): Promise<void>;
+    assertJsiiPackagesAvailable(): void;
+    initializeDotnetPackages(currentDir: string): Promise<void>;
+    majorVersion(): string;
+    requestedFrameworkVersion(): string;
+    requestedAlphaVersion(): string;
+}

package/lib/package-sources/release-source.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleasePackageSource = exports.ReleasePackageSourceSetup = void 0;
+const os = require("os");
+const path = require("path");
+const fs = require("fs-extra");
+const files_1 = require("../files");
+const shell_1 = require("../shell");
+class ReleasePackageSourceSetup {
+    constructor(version, frameworkVersion) {
+        this.version = version;
+        this.frameworkVersion = frameworkVersion;
+        this.name = 'release';
+        this.description = `release @ ${this.version}`;
+    }
+    async prepare() {
+        this.tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmpcdk'));
+        fs.mkdirSync(this.tempDir, { recursive: true });
+        await shell_1.shell(['node', require.resolve('npm'), 'install', `aws-cdk@${this.version}`], {
+            cwd: this.tempDir,
+        });
+        process.env.CDK_CLI_PATH = this.tempDir;
+        process.env.VERSION = this.version;
+        process.env.FRAMEWORK_VERSION = this.frameworkVersion ?? this.version;
+    }
+    async cleanup() {
+        if (this.tempDir) {
+            shell_1.rimraf(this.tempDir);
+        }
+    }
+}
+exports.ReleasePackageSourceSetup = ReleasePackageSourceSetup;
+class ReleasePackageSource {
+    constructor() {
+        this.cliPath = process.env.CDK_CLI_PATH;
+        this.version = process.env.VERSION;
+    }
+    async makeCliAvailable() {
+        shell_1.addToShellPath(path.join(this.cliPath, 'node_modules', '.bin'));
+    }
+    assertJsiiPackagesAvailable() {
+    }
+    async initializeDotnetPackages(currentDir) {
+        if (process.env.CWD_FILES_DIR) {
+            await files_1.copyDirectoryContents(process.env.CWD_FILES_DIR, currentDir);
+        }
+    }
+    majorVersion() {
+        return this.version.split('.')[0];
+    }
+    requestedFrameworkVersion() {
+        return process.env.FRAMEWORK_VERSION;
+    }
+    requestedAlphaVersion() {
+        const frameworkVersion = this.requestedFrameworkVersion();
+        if (frameworkVersion.includes('-rc.')) {
+            // For a pipeline release
+            return frameworkVersion.replace(/-rc\.\d+$/, '-alpha.999');
+        }
+        else {
+            // For a stable release
+            return `${frameworkVersion}-alpha.0`;
+        }
+    }
+}
+exports.ReleasePackageSource = ReleasePackageSource;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/repo-source.d.ts

@@ -0,0 +1,23 @@
+import { IPackageSourceSetup, IPackageSource } from './source';
+export declare class RepoPackageSourceSetup implements IPackageSourceSetup {
+    private readonly repoRoot;
+    readonly name = "repo";
+    readonly description: string;
+    constructor(repoRoot: string);
+    prepare(): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export declare class RepoPackageSource implements IPackageSource {
+    private readonly repoRoot;
+    constructor();
+    makeCliAvailable(): Promise<void>;
+    assertJsiiPackagesAvailable(): void;
+    initializeDotnetPackages(): Promise<void>;
+    majorVersion(): any;
+    requestedFrameworkVersion(): string;
+    requestedAlphaVersion(): string;
+}
+/**
+ * Find the root directory of the repo from the current directory
+ */
+export declare function autoFindRoot(): Promise<string>;

package/lib/package-sources/repo-source.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoFindRoot = exports.RepoPackageSource = exports.RepoPackageSourceSetup = void 0;
+const os = require("os");
+const path = require("path");
+const fs = require("fs-extra");
+const files_1 = require("../files");
+const shell_1 = require("../shell");
+class RepoPackageSourceSetup {
+    constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+        this.name = 'repo';
+        this.description = `repo(${this.repoRoot})`;
+    }
+    async prepare() {
+        if (!await fs.pathExists(path.join(this.repoRoot, 'package.json')) || !await fs.pathExists(path.join(this.repoRoot, 'yarn.lock'))) {
+            throw new Error(`${this.repoRoot}: does not look like the repository root`);
+        }
+        process.env.REPO_ROOT = this.repoRoot;
+        process.env.REPO_PACKAGE_MAP = await writePackageMap(this.repoRoot);
+        shell_1.addToShellPath(path.resolve(__dirname, 'repo-tools'));
+    }
+    async cleanup() {
+    }
+}
+exports.RepoPackageSourceSetup = RepoPackageSourceSetup;
+class RepoPackageSource {
+    constructor() {
+        this.repoRoot = process.env.REPO_ROOT;
+    }
+    async makeCliAvailable() {
+        shell_1.addToShellPath(path.join(this.repoRoot, 'packages', 'aws-cdk', 'bin'));
+    }
+    assertJsiiPackagesAvailable() {
+        throw new Error('jsii client packages are not available when using REPO source');
+    }
+    async initializeDotnetPackages() {
+    }
+    majorVersion() {
+        const releaseJson = fs.readJsonSync(path.resolve(this.repoRoot, 'release.json'));
+        return releaseJson.majorVersion;
+    }
+    requestedFrameworkVersion() {
+        return '*';
+    }
+    requestedAlphaVersion() {
+        return '*';
+    }
+}
+exports.RepoPackageSource = RepoPackageSource;
+async function writePackageMap(repoRoot) {
+    const packages = await findYarnPackages(repoRoot);
+    const fileName = path.join(os.tmpdir(), 'package-map.json');
+    await fs.writeJson(fileName, packages);
+    return fileName;
+}
+/**
+ * Cache monorepo discovery results, we only want to do this once per run
+ */
+const YARN_MONOREPO_CACHE = {};
+/**
+  * Return a { name -> directory } packages found in a Yarn monorepo
+  *
+  * Cached in YARN_MONOREPO_CACHE.
+  */
+async function findYarnPackages(root) {
+    if (!(root in YARN_MONOREPO_CACHE)) {
+        const output = JSON.parse(await shell_1.shell(['yarn', 'workspaces', '--silent', 'info'], {
+            captureStderr: false,
+            cwd: root,
+            show: 'error',
+        }));
+        const ret = {};
+        for (const [k, v] of Object.entries(output)) {
+            ret[k] = path.join(root, v.location);
+        }
+        YARN_MONOREPO_CACHE[root] = ret;
+    }
+    return YARN_MONOREPO_CACHE[root];
+}
+/**
+ * Find the root directory of the repo from the current directory
+ */
+async function autoFindRoot() {
+    const found = await files_1.findUp('release.json');
+    if (!found) {
+        throw new Error(`Could not determine repository root: 'release.json' not found from ${process.cwd()}`);
+    }
+    return path.dirname(found);
+}
+exports.autoFindRoot = autoFindRoot;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/repo-tools/npm

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./npm.js');

package/lib/package-sources/repo-tools/npm.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/package-sources/repo-tools/npm.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process = require("child_process");
+const fs = require("fs-extra");
+let argv = process.argv.slice(2);
+// eslint-disable-next-line no-console
+console.log('fake npm');
+if (argv[0] === 'install') {
+    if (!process.env.REPO_PACKAGE_MAP) {
+        throw new Error('REPO_PACKAGE_MAP not set');
+    }
+    const repoPackageMap = fs.readJsonSync(process.env.REPO_PACKAGE_MAP, { encoding: 'utf-8' });
+    // Replace paths in the 'package.json' in the current directory
+    if (fs.pathExistsSync('package.json')) {
+        const packageJson = fs.readJsonSync('package.json', { encoding: 'utf-8' });
+        for (const deps of [packageJson.dependencies ?? {}, packageJson.devDependencies ?? {}]) {
+            for (const [name, version] of Object.entries(deps)) {
+                deps[name] = repoPackageMap[name] ?? version;
+            }
+        }
+        fs.writeJsonSync('package.json', packageJson, { encoding: 'utf-8' });
+    }
+    // Replace package names on the command line
+    argv = argv.map(x => repoPackageMap[x] ?? x);
+}
+////////////////////////////////////////////////////////////////////////
+//  Shell out to original npm
+const child = child_process.spawn('node', [require.resolve('npm'), ...argv], {
+    shell: false,
+    stdio: ['ignore', 'inherit', 'inherit'],
+});
+child.once('error', e => {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    process.exitCode = 1;
+});
+child.once('close', code => {
+    if (code) {
+        process.exitCode = code;
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/source.d.ts

@@ -0,0 +1,24 @@
+export interface IPackageSourceSetup {
+    readonly name: string;
+    readonly description: string;
+    prepare(): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export interface IPackageSource {
+    makeCliAvailable(): Promise<void>;
+    assertJsiiPackagesAvailable(): void;
+    majorVersion(): string;
+    initializeDotnetPackages(targetDir: string): Promise<void>;
+    /**
+     * Framework version if it's different than the CLI version
+     *
+     * Not all tests will respect this.
+     */
+    requestedFrameworkVersion(): string;
+    /**
+     * Versions of alpha packages if different than the CLI version
+     *
+     * Not all tests will respect this.
+     */
+    requestedAlphaVersion(): string;
+}

package/lib/package-sources/source.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic291cmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIElQYWNrYWdlU291cmNlU2V0dXAge1xuICByZWFkb25seSBuYW1lOiBzdHJpbmc7XG4gIHJlYWRvbmx5IGRlc2NyaXB0aW9uOiBzdHJpbmc7XG5cbiAgcHJlcGFyZSgpOiBQcm9taXNlPHZvaWQ+O1xuICBjbGVhbnVwKCk6IFByb21pc2U8dm9pZD47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSVBhY2thZ2VTb3VyY2Uge1xuICBtYWtlQ2xpQXZhaWxhYmxlKCk6IFByb21pc2U8dm9pZD47XG5cbiAgYXNzZXJ0SnNpaVBhY2thZ2VzQXZhaWxhYmxlKCk6IHZvaWQ7XG4gIG1ham9yVmVyc2lvbigpOiBzdHJpbmc7XG5cbiAgaW5pdGlhbGl6ZURvdG5ldFBhY2thZ2VzKHRhcmdldERpcjogc3RyaW5nKTogUHJvbWlzZTx2b2lkPjtcblxuICAvKipcbiAgICogRnJhbWV3b3JrIHZlcnNpb24gaWYgaXQncyBkaWZmZXJlbnQgdGhhbiB0aGUgQ0xJIHZlcnNpb25cbiAgICpcbiAgICogTm90IGFsbCB0ZXN0cyB3aWxsIHJlc3BlY3QgdGhpcy5cbiAgICovXG4gIHJlcXVlc3RlZEZyYW1ld29ya1ZlcnNpb24oKTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBWZXJzaW9ucyBvZiBhbHBoYSBwYWNrYWdlcyBpZiBkaWZmZXJlbnQgdGhhbiB0aGUgQ0xJIHZlcnNpb25cbiAgICpcbiAgICogTm90IGFsbCB0ZXN0cyB3aWxsIHJlc3BlY3QgdGhpcy5cbiAgICovXG4gIHJlcXVlc3RlZEFscGhhVmVyc2lvbigpOiBzdHJpbmc7XG59Il19

package/lib/package-sources/subprocess.d.ts

@@ -0,0 +1,3 @@
+import { IPackageSourceSetup, IPackageSource } from './source';
+export declare function serializeForSubprocess(s: IPackageSourceSetup): void;
+export declare function packageSourceInSubprocess(): IPackageSource;

package/lib/package-sources/subprocess.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageSourceInSubprocess = exports.serializeForSubprocess = void 0;
+const release_source_1 = require("./release-source");
+const repo_source_1 = require("./repo-source");
+function serializeForSubprocess(s) {
+    process.env.PACKAGE_SOURCE = s.name;
+}
+exports.serializeForSubprocess = serializeForSubprocess;
+function packageSourceInSubprocess() {
+    switch (process.env.PACKAGE_SOURCE) {
+        case 'repo': return new repo_source_1.RepoPackageSource();
+        case 'release': return new release_source_1.ReleasePackageSource();
+        default: throw new Error(`Unrecognized package source: ${process.env.PACKAGE_SOURCE}`);
+    }
+}
+exports.packageSourceInSubprocess = packageSourceInSubprocess;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3VicHJvY2Vzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInN1YnByb2Nlc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscURBQXdEO0FBQ3hELCtDQUFrRDtBQUdsRCxTQUFnQixzQkFBc0IsQ0FBQyxDQUFzQjtJQUMzRCxPQUFPLENBQUMsR0FBRyxDQUFDLGNBQWMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDO0FBQ3RDLENBQUM7QUFGRCx3REFFQztBQUVELFNBQWdCLHlCQUF5QjtJQUN2QyxRQUFRLE9BQU8sQ0FBQyxHQUFHLENBQUMsY0FBYyxFQUFFO1FBQ2xDLEtBQUssTUFBTSxDQUFDLENBQUMsT0FBTyxJQUFJLCtCQUFpQixFQUFFLENBQUM7UUFDNUMsS0FBSyxTQUFTLENBQUMsQ0FBQyxPQUFPLElBQUkscUNBQW9CLEVBQUUsQ0FBQztRQUNsRCxPQUFPLENBQUMsQ0FBQyxNQUFNLElBQUksS0FBSyxDQUFDLGdDQUFnQyxPQUFPLENBQUMsR0FBRyxDQUFDLGNBQWMsRUFBRSxDQUFDLENBQUM7S0FDeEY7QUFDSCxDQUFDO0FBTkQsOERBTUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZWxlYXNlUGFja2FnZVNvdXJjZSB9IGZyb20gJy4vcmVsZWFzZS1zb3VyY2UnO1xuaW1wb3J0IHsgUmVwb1BhY2thZ2VTb3VyY2UgfSBmcm9tICcuL3JlcG8tc291cmNlJztcbmltcG9ydCB7IElQYWNrYWdlU291cmNlU2V0dXAsIElQYWNrYWdlU291cmNlIH0gZnJvbSAnLi9zb3VyY2UnO1xuXG5leHBvcnQgZnVuY3Rpb24gc2VyaWFsaXplRm9yU3VicHJvY2VzcyhzOiBJUGFja2FnZVNvdXJjZVNldHVwKSB7XG4gIHByb2Nlc3MuZW52LlBBQ0tBR0VfU09VUkNFID0gcy5uYW1lO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gcGFja2FnZVNvdXJjZUluU3VicHJvY2VzcygpOiBJUGFja2FnZVNvdXJjZSB7XG4gIHN3aXRjaCAocHJvY2Vzcy5lbnYuUEFDS0FHRV9TT1VSQ0UpIHtcbiAgICBjYXNlICdyZXBvJzogcmV0dXJuIG5ldyBSZXBvUGFja2FnZVNvdXJjZSgpO1xuICAgIGNhc2UgJ3JlbGVhc2UnOiByZXR1cm4gbmV3IFJlbGVhc2VQYWNrYWdlU291cmNlKCk7XG4gICAgZGVmYXVsdDogdGhyb3cgbmV3IEVycm9yKGBVbnJlY29nbml6ZWQgcGFja2FnZSBzb3VyY2U6ICR7cHJvY2Vzcy5lbnYuUEFDS0FHRV9TT1VSQ0V9YCk7XG4gIH1cbn0iXX0=

package/lib/resource-pool.d.ts

@@ -0,0 +1,54 @@
+/**
+ * A class that holds a pool of resources and gives them out and returns them on-demand
+ *
+ * The resources will be given out front to back, when they are returned
+ * the most recently returned version will be given out again (for best
+ * cache coherency).
+ *
+ * If there are multiple consumers waiting for a resource, consumers are serviced
+ * in FIFO order for most fairness.
+ */
+export declare class ResourcePool<A extends string = string> {
+    private readonly pool;
+    static withResources<A extends string>(name: string, resources: A[]): ResourcePool<A>;
+    private readonly resources;
+    private readonly mutexes;
+    private readonly locks;
+    private constructor();
+    /**
+     * Take one value from the resource pool
+     *
+     * If no such value is currently available, wait until it is.
+     */
+    take(): Promise<ILease<A>>;
+    /**
+     * Execute a block using a single resource from the pool
+     */
+    using<B>(block: (x: A) => B | Promise<B>): Promise<B>;
+    private tryObtainLease;
+    private makeLease;
+    /**
+     * When a value is returned:
+     *
+     * - If someone's waiting for it, give it to them
+     * - Otherwise put it back into the pool
+     */
+    private returnValue;
+    /**
+     * Return all resources that we definitely don't own the locks for
+     */
+    private unlockedResources;
+}
+/**
+ * A single value taken from the pool
+ */
+export interface ILease<A> {
+    /**
+     * The value obtained by the lease
+     */
+    readonly value: A;
+    /**
+     * Return the leased value to the pool
+     */
+    dispose(): Promise<void>;
+}

package/lib/resource-pool.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourcePool = void 0;
+const xpmutex_1 = require("./xpmutex");
+/**
+ * A class that holds a pool of resources and gives them out and returns them on-demand
+ *
+ * The resources will be given out front to back, when they are returned
+ * the most recently returned version will be given out again (for best
+ * cache coherency).
+ *
+ * If there are multiple consumers waiting for a resource, consumers are serviced
+ * in FIFO order for most fairness.
+ */
+class ResourcePool {
+    constructor(pool, resources) {
+        this.pool = pool;
+        this.mutexes = {};
+        this.locks = {};
+        if (resources.length === 0) {
+            throw new Error('Must have at least one resource in the pool');
+        }
+        // Shuffle to reduce contention
+        resources = [...resources];
+        fisherYatesShuffle(resources);
+        this.resources = resources;
+        for (const res of resources) {
+            this.mutexes[res] = this.pool.mutex(res);
+        }
+    }
+    static withResources(name, resources) {
+        const pool = xpmutex_1.XpMutexPool.fromName(name);
+        return new ResourcePool(pool, resources);
+    }
+    /**
+     * Take one value from the resource pool
+     *
+     * If no such value is currently available, wait until it is.
+     */
+    async take() {
+        while (true) {
+            // Start a wait on the unlock now -- if the unlock signal comes after
+            // we try to acquire but before we start the wait, we might miss it.
+            const wait = this.pool.awaitUnlock(5000);
+            for (const res of this.unlockedResources()) {
+                const lease = await this.tryObtainLease(res);
+                if (lease) {
+                    // Ignore the wait (count as handled)
+                    wait.then(() => { }, () => { });
+                    return lease;
+                }
+            }
+            // None available, wait until one gets unlocked then try again
+            await wait;
+        }
+    }
+    /**
+     * Execute a block using a single resource from the pool
+     */
+    async using(block) {
+        const lease = await this.take();
+        try {
+            return await block(lease.value);
+        }
+        finally {
+            await lease.dispose();
+        }
+    }
+    async tryObtainLease(value) {
+        const lock = await this.mutexes[value].tryAcquire();
+        if (!lock) {
+            return undefined;
+        }
+        this.locks[value] = lock;
+        return this.makeLease(value);
+    }
+    makeLease(value) {
+        let disposed = false;
+        return {
+            value,
+            dispose: () => {
+                if (disposed) {
+                    throw new Error('Calling dispose() on an already-disposed lease.');
+                }
+                disposed = true;
+                return this.returnValue(value);
+            },
+        };
+    }
+    /**
+     * When a value is returned:
+     *
+     * - If someone's waiting for it, give it to them
+     * - Otherwise put it back into the pool
+     */
+    async returnValue(value) {
+        const lock = this.locks[value];
+        delete this.locks[value];
+        await lock?.release();
+    }
+    /**
+     * Return all resources that we definitely don't own the locks for
+     */
+    unlockedResources() {
+        return this.resources.filter(res => !this.locks[res]);
+    }
+}
+exports.ResourcePool = ResourcePool;
+/**
+ * Shuffle an array in-place
+ */
+function fisherYatesShuffle(xs) {
+    for (let i = xs.length - 1; i >= 1; i--) {
+        const j = Math.floor(Math.random() * i);
+        const h = xs[j];
+        xs[j] = xs[i];
+        xs[i] = h;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-pool.js","sourceRoot":"","sources":["resource-pool.ts"],"names":[],"mappings":"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","sourcesContent":["import { ILock, XpMutex, XpMutexPool } from './xpmutex';\n\n/**\n * A class that holds a pool of resources and gives them out and returns them on-demand\n *\n * The resources will be given out front to back, when they are returned\n * the most recently returned version will be given out again (for best\n * cache coherency).\n *\n * If there are multiple consumers waiting for a resource, consumers are serviced\n * in FIFO order for most fairness.\n */\nexport class ResourcePool<A extends string=string> {\n  public static withResources<A extends string>(name: string, resources: A[]) {\n    const pool = XpMutexPool.fromName(name);\n    return new ResourcePool(pool, resources);\n  }\n\n  private readonly resources: ReadonlyArray<A>;\n  private readonly mutexes: Record<string, XpMutex> = {};\n  private readonly locks: Record<string, ILock | undefined> = {};\n\n  private constructor(private readonly pool: XpMutexPool, resources: A[]) {\n    if (resources.length === 0) {\n      throw new Error('Must have at least one resource in the pool');\n    }\n\n    // Shuffle to reduce contention\n    resources = [...resources];\n    fisherYatesShuffle(resources);\n    this.resources = resources;\n\n    for (const res of resources) {\n      this.mutexes[res] = this.pool.mutex(res);\n    }\n  }\n\n  /**\n   * Take one value from the resource pool\n   *\n   * If no such value is currently available, wait until it is.\n   */\n  public async take(): Promise<ILease<A>> {\n    while (true) {\n      // Start a wait on the unlock now -- if the unlock signal comes after\n      // we try to acquire but before we start the wait, we might miss it.\n      const wait = this.pool.awaitUnlock(5000);\n\n      for (const res of this.unlockedResources()) {\n        const lease = await this.tryObtainLease(res);\n        if (lease) {\n          // Ignore the wait (count as handled)\n          wait.then(() => {}, () => {});\n          return lease;\n        }\n      }\n\n      // None available, wait until one gets unlocked then try again\n      await wait;\n    }\n  }\n\n  /**\n   * Execute a block using a single resource from the pool\n   */\n  public async using<B>(block: (x: A) => B | Promise<B>): Promise<B> {\n    const lease = await this.take();\n    try {\n      return await block(lease.value);\n    } finally {\n      await lease.dispose();\n    }\n  }\n\n  private async tryObtainLease(value: A) {\n    const lock = await this.mutexes[value].tryAcquire();\n    if (!lock) {\n      return undefined;\n    }\n\n    this.locks[value] = lock;\n    return this.makeLease(value);\n  }\n\n  private makeLease(value: A): ILease<A> {\n    let disposed = false;\n    return {\n      value,\n      dispose: () => {\n        if (disposed) {\n          throw new Error('Calling dispose() on an already-disposed lease.');\n        }\n        disposed = true;\n        return this.returnValue(value);\n      },\n    };\n  }\n\n  /**\n   * When a value is returned:\n   *\n   * - If someone's waiting for it, give it to them\n   * - Otherwise put it back into the pool\n   */\n  private async returnValue(value: string) {\n    const lock = this.locks[value];\n    delete this.locks[value];\n    await lock?.release();\n  }\n\n  /**\n   * Return all resources that we definitely don't own the locks for\n   */\n  private unlockedResources(): A[] {\n    return this.resources.filter(res => !this.locks[res]);\n  }\n}\n\n/**\n * A single value taken from the pool\n */\nexport interface ILease<A> {\n  /**\n   * The value obtained by the lease\n   */\n  readonly value: A;\n\n  /**\n   * Return the leased value to the pool\n   */\n  dispose(): Promise<void>;\n}\n\n/**\n * Shuffle an array in-place\n */\nfunction fisherYatesShuffle<A>(xs: A[]) {\n  for (let i = xs.length - 1; i >= 1; i--) {\n    const j = Math.floor(Math.random() * i);\n    const h = xs[j];\n    xs[j] = xs[i];\n    xs[i] = h;\n  }\n}\n"]}

package/lib/resources.d.ts

@@ -0,0 +1 @@
+export declare const RESOURCES_DIR: string;

package/lib/resources.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOURCES_DIR = void 0;
+const path = require("path");
+exports.RESOURCES_DIR = path.resolve(__dirname, '..', 'resources');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb3VyY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsicmVzb3VyY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDZCQUE2QjtBQUVoQixRQUFBLGFBQWEsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxJQUFJLEVBQUUsV0FBVyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBwYXRoIGZyb20gJ3BhdGgnO1xuXG5leHBvcnQgY29uc3QgUkVTT1VSQ0VTX0RJUiA9IHBhdGgucmVzb2x2ZShfX2Rpcm5hbWUsICcuLicsICdyZXNvdXJjZXMnKTtcblxuIl19