build-raptor 0.131.0 → 0.133.0

package/dist/deps/logger/logger.d.ts

@@ -0,0 +1,26 @@
+export type Criticality = 'high' | 'moderate' | 'low';
+export interface Logger {
+    print(message: string, criticality?: Criticality): void;
+    info(message: string, ...rest: unknown[]): void;
+    debug(message: string, ...rest: unknown[]): void;
+    error(message: string, err: unknown, ...rest: unknown[]): void;
+}
+declare class NopLogger implements Logger {
+    print(_message: string): void;
+    info(_message: string, ..._rest: unknown[]): void;
+    debug(_message: string, ..._rest: unknown[]): void;
+    error(_message: string, _err: unknown, ..._rest: unknown[]): void;
+}
+export declare function createNopLogger(): NopLogger;
+export declare function createDefaultLogger(logFile: string, pickiness: Criticality, logLevel?: Level, uiStream?: NodeJS.WritableStream): FileLogger;
+declare class FileLogger implements Logger {
+    private readonly logger;
+    private readonly pickiness;
+    constructor(logFile: string, pickinessLevel: Criticality, logLevel?: Level, uiStream?: NodeJS.WritableStream);
+    print(message: string, messageCriticality?: Criticality): void;
+    info(message: string, ...rest: unknown[]): void;
+    debug(message: string, ...rest: unknown[]): void;
+    error(message: string, err: unknown, ...rest: unknown[]): void;
+}
+type Level = 'error' | 'info' | 'debug';
+export {};

package/dist/deps/logger/logger.js

@@ -0,0 +1,152 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNopLogger = createNopLogger;
+exports.createDefaultLogger = createDefaultLogger;
+const fs = __importStar(require("fs"));
+const logform_1 = require("logform");
+const path = __importStar(require("path"));
+const safe_stable_stringify_1 = __importDefault(require("safe-stable-stringify"));
+const winston = __importStar(require("winston"));
+const criticalityLegend = {
+    high: 0,
+    moderate: 100,
+    low: 200,
+};
+class NopLogger {
+    print(_message) {
+        // noop
+    }
+    info(_message, ..._rest) {
+        // noop
+    }
+    debug(_message, ..._rest) {
+        // noop
+    }
+    error(_message, _err, ..._rest) {
+        // noop
+    }
+}
+function createNopLogger() {
+    return new NopLogger();
+}
+function createDefaultLogger(logFile, pickiness, logLevel, uiStream) {
+    const stat = fs.statSync(logFile, { throwIfNoEntry: false });
+    if (stat && stat.size > 0) {
+        fs.rmSync(logFile, { force: true });
+    }
+    return new FileLogger(logFile, pickiness, logLevel, uiStream);
+}
+class FileLogger {
+    constructor(logFile, pickinessLevel, logLevel = 'info', uiStream = process.stdout) {
+        if (!path.isAbsolute(logFile)) {
+            throw new Error(`logDir must be absolute: ${logFile}`);
+        }
+        this.logger = newLogger(logFile, logLevel, uiStream);
+        this.pickiness = criticalityLegend[pickinessLevel];
+    }
+    print(message, messageCriticality = 'moderate') {
+        const messageLevel = criticalityLegend[messageCriticality];
+        const doPrint = messageLevel <= this.pickiness;
+        if (doPrint) {
+            this.logger.info(message, { ui: true });
+        }
+    }
+    info(message, ...rest) {
+        this.logger.info(message, ...rest);
+    }
+    debug(message, ...rest) {
+        this.logger.debug(message, ...rest);
+    }
+    error(message, err, ...rest) {
+        this.logger.error(message, err, ...rest, { ui: true });
+    }
+}
+const joinTokens = (...tokens) => tokens
+    .map(t => t?.trim())
+    .filter(Boolean)
+    .join(' ');
+const finalFormat = logform_1.format.printf(info => {
+    let stringifiedRest = (0, safe_stable_stringify_1.default)(Object.assign({}, info, {
+        level: undefined,
+        message: undefined,
+        timestamp: undefined,
+        stack: undefined,
+        ui: undefined,
+    }));
+    if (stringifiedRest === '{}') {
+        stringifiedRest = '';
+    }
+    return joinTokens(info.timestamp, `[${info.level}]`, info.message, stringifiedRest, info.stack);
+});
+const filterUi = (0, logform_1.format)(info => {
+    if (!info.ui) {
+        return false;
+    }
+    return info;
+});
+const formatUi = logform_1.format.printf(info => {
+    return joinTokens(info.message, info.stack);
+});
+const levels = {
+    error: 0,
+    info: 1,
+    debug: 2,
+};
+function newLogger(logFile, level, uiStream) {
+    return winston.createLogger({
+        level: 'debug',
+        levels,
+        defaultMeta: undefined,
+        transports: [
+            // Writes all log entries with level `info` and below to logFile.
+            new winston.transports.File({
+                filename: logFile,
+                level,
+                format: logform_1.format.combine(logform_1.format.timestamp(), logform_1.format.errors({ stack: true }), finalFormat),
+            }),
+            // Writes all logs entries marked as "UI" to the the UI stream (typically, stdout).
+            new winston.transports.Stream({
+                stream: uiStream,
+                level: 'info',
+                format: logform_1.format.combine(logform_1.format.errors({ stack: true }), filterUi(), formatUi),
+            }),
+        ],
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/deps/misc/arrays.d.ts

@@ -0,0 +1,7 @@
+export declare function sortBy<T>(input: readonly T[], key: (item: T) => number): T[];
+export declare function sortBy<T>(input: readonly T[], key: (item: T) => string): T[];
+export declare function sortBy<T>(input: IterableIterator<T>, key: (item: T) => number): T[];
+export declare function sortBy<T>(input: IterableIterator<T>, key: (item: T) => string): T[];
+export declare function findDups<T, K extends number | symbol | string>(input: ArrayLike<T> | Iterable<T>, key: (item: T) => K): T[];
+export declare function uniqueBy<T, K>(input: ArrayLike<T> | Iterable<T>, key: (item: T) => K): T[];
+export declare function groupBy<T, K extends number | symbol | string>(input: ArrayLike<T> | Iterable<T>, key: (item: T) => K): Record<K, T[]>;

package/dist/deps/misc/arrays.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortBy = sortBy;
+exports.findDups = findDups;
+exports.uniqueBy = uniqueBy;
+exports.groupBy = groupBy;
+const maps_1 = require("./maps");
+function sortBy(input, key) {
+    return [...input].sort((a, b) => comp(a, b, key));
+}
+function comp(a, b, key) {
+    const ak = key(a);
+    const bk = key(b);
+    if (typeof ak === 'string' && typeof bk === 'string') {
+        return ak.localeCompare(bk);
+    }
+    if (typeof ak === 'number' && typeof bk === 'number') {
+        return ak - bk;
+    }
+    throw new Error(`Cannot compare ${ak} and ${bk}`);
+}
+function findDups(input, key) {
+    const counts = new Map();
+    const collidingKeys = new Set();
+    const pairs = [];
+    for (const item of Array.from(input)) {
+        const k = key(item);
+        pairs.push([item, k]);
+        const n = (0, maps_1.mapIncrement)(counts, k, 1);
+        if (n > 1) {
+            collidingKeys.add(k);
+        }
+    }
+    const ret = [];
+    for (const [item, k] of pairs) {
+        if (collidingKeys.has(k)) {
+            ret.push(item);
+        }
+    }
+    return ret;
+}
+function uniqueBy(input, key) {
+    const seen = new Set();
+    return Array.from(input).filter(item => {
+        const k = key(item);
+        if (seen.has(k)) {
+            return false;
+        }
+        seen.add(k);
+        return true;
+    });
+}
+function groupBy(input, key) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const ret = {};
+    for (const item of Array.from(input)) {
+        const k = key(item);
+        let arr = ret[k];
+        if (!arr) {
+            arr = new Array();
+            ret[k] = arr;
+        }
+        arr.push(item);
+    }
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/deps/misc/camelize-record.d.ts

@@ -0,0 +1,6 @@
+type CamelizeString<T extends PropertyKey, C extends string = ''> = T extends string ? string extends T ? string : T extends `${infer F}-${infer R}` ? CamelizeString<Capitalize<R>, `${C}${F}`> : `${C}${T}` : T;
+export type CamelizeRecord<T> = {
+    [K in keyof T as CamelizeString<K>]: T[K];
+};
+export declare function camelizeRecord<T extends Record<string, boolean | string | number | unknown>>(rec: T): CamelizeRecord<T>;
+export {};

package/dist/deps/misc/camelize-record.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.camelizeRecord = camelizeRecord;
+function camelizeRecord(rec) {
+    const ret = {};
+    for (const k of Object.keys(rec)) {
+        const parts = k.split('-');
+        if (parts.length === 1) {
+            ret[k] = rec[k];
+            continue;
+        }
+        ret[parts.map((p, i) => (i === 0 ? p : p[0].toUpperCase() + p.slice(1))).join('')] = rec[k];
+    }
+    return ret; // eslint-disable-line @typescript-eslint/consistent-type-assertions
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FtZWxpemUtcmVjb3JkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NhbWVsaXplLXJlY29yZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVVBLHdDQWdCQztBQWhCRCxTQUFnQixjQUFjLENBQzVCLEdBQU07SUFFTixNQUFNLEdBQUcsR0FBNEIsRUFBRSxDQUFBO0lBRXZDLEtBQUssTUFBTSxDQUFDLElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ2pDLE1BQU0sS0FBSyxHQUFHLENBQUMsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDMUIsSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ3ZCLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUE7WUFDZixTQUFRO1FBQ1YsQ0FBQztRQUVELEdBQUcsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxXQUFXLEVBQUUsR0FBRyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUE7SUFDN0YsQ0FBQztJQUVELE9BQU8sR0FBd0IsQ0FBQSxDQUFDLG9FQUFvRTtBQUN0RyxDQUFDIn0=

package/dist/deps/misc/clean-directory.d.ts

@@ -0,0 +1,4 @@
+export declare function cleanDirectory(directoryPath: string, deletionFactor: number, triggerCleanupIfByteSizeExceeds: number | 'ALWAYS'): {
+    size: number;
+    deleted: number;
+};

package/dist/deps/misc/clean-directory.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanDirectory = cleanDirectory;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const arrays_1 = require("./arrays");
+function cleanDirectory(directoryPath, deletionFactor, triggerCleanupIfByteSizeExceeds) {
+    const size = calculateDirectorySize(directoryPath);
+    if (triggerCleanupIfByteSizeExceeds !== 'ALWAYS' && size <= triggerCleanupIfByteSizeExceeds) {
+        return { size, deleted: 0 };
+    }
+    const filesDeleted = deleteFiles(directoryPath, deletionFactor);
+    return { size, deleted: filesDeleted.length };
+}
+function calculateDirectorySize(directoryPath) {
+    let ret = 0;
+    for (const f of fs.readdirSync(directoryPath)) {
+        const resolved = path.join(directoryPath, f);
+        const stats = fs.statSync(resolved);
+        ret += stats.size;
+    }
+    return ret;
+}
+function deleteFiles(directoryPath, deletionFactor) {
+    let files;
+    try {
+        files = fs.readdirSync(directoryPath);
+    }
+    catch (e) {
+        throw new Error(`failed when reading ${directoryPath}: ${e}`);
+    }
+    const mapped = files.map(f => ({ f, atime: fs.statSync(path.join(directoryPath, f)).atime.toISOString() }));
+    const sorted = (0, arrays_1.sortBy)(mapped, at => at.atime);
+    const numFilesToDelete = Math.min(sorted.length, Math.floor(sorted.length * deletionFactor));
+    const ret = sorted.slice(0, numFilesToDelete).map(at => at.f);
+    for (const f of ret) {
+        const filePath = path.join(directoryPath, f);
+        try {
+            fs.unlinkSync(filePath);
+        }
+        catch (e) {
+            throw new Error(`cleanup of ${filePath} failed: ${e}`);
+        }
+    }
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xlYW4tZGlyZWN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NsZWFuLWRpcmVjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUtBLHdDQVlDO0FBakJELHVDQUF3QjtBQUN4QiwyQ0FBNEI7QUFFNUIscUNBQWlDO0FBRWpDLFNBQWdCLGNBQWMsQ0FDNUIsYUFBcUIsRUFDckIsY0FBc0IsRUFDdEIsK0JBQWtEO0lBRWxELE1BQU0sSUFBSSxHQUFHLHNCQUFzQixDQUFDLGFBQWEsQ0FBQyxDQUFBO0lBQ2xELElBQUksK0JBQStCLEtBQUssUUFBUSxJQUFJLElBQUksSUFBSSwrQkFBK0IsRUFBRSxDQUFDO1FBQzVGLE9BQU8sRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLENBQUMsRUFBRSxDQUFBO0lBQzdCLENBQUM7SUFFRCxNQUFNLFlBQVksR0FBRyxXQUFXLENBQUMsYUFBYSxFQUFFLGNBQWMsQ0FBQyxDQUFBO0lBQy9ELE9BQU8sRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLFlBQVksQ0FBQyxNQUFNLEVBQUUsQ0FBQTtBQUMvQyxDQUFDO0FBRUQsU0FBUyxzQkFBc0IsQ0FBQyxhQUFxQjtJQUNuRCxJQUFJLEdBQUcsR0FBRyxDQUFDLENBQUE7SUFFWCxLQUFLLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxXQUFXLENBQUMsYUFBYSxDQUFDLEVBQUUsQ0FBQztRQUM5QyxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDLENBQUMsQ0FBQTtRQUM1QyxNQUFNLEtBQUssR0FBRyxFQUFFLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxDQUFBO1FBQ25DLEdBQUcsSUFBSSxLQUFLLENBQUMsSUFBSSxDQUFBO0lBQ25CLENBQUM7SUFFRCxPQUFPLEdBQUcsQ0FBQTtBQUNaLENBQUM7QUFFRCxTQUFTLFdBQVcsQ0FBQyxhQUFxQixFQUFFLGNBQXNCO0lBQ2hFLElBQUksS0FBSyxDQUFBO0lBRVQsSUFBSSxDQUFDO1FBQ0gsS0FBSyxHQUFHLEVBQUUsQ0FBQyxXQUFXLENBQUMsYUFBYSxDQUFDLENBQUE7SUFDdkMsQ0FBQztJQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7UUFDWCxNQUFNLElBQUksS0FBSyxDQUFDLHVCQUF1QixhQUFhLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQTtJQUMvRCxDQUFDO0lBRUQsTUFBTSxNQUFNLEdBQUcsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsV0FBVyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUE7SUFDM0csTUFBTSxNQUFNLEdBQUcsSUFBQSxlQUFNLEVBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFBO0lBRTdDLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLE1BQU0sR0FBRyxjQUFjLENBQUMsQ0FBQyxDQUFBO0lBQzVGLE1BQU0sR0FBRyxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLGdCQUFnQixDQUFDLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBRTdELEtBQUssTUFBTSxDQUFDLElBQUksR0FBRyxFQUFFLENBQUM7UUFDcEIsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQyxDQUFDLENBQUE7UUFFNUMsSUFBSSxDQUFDO1lBQ0gsRUFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUMsQ0FBQTtRQUN6QixDQUFDO1FBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztZQUNYLE1BQU0sSUFBSSxLQUFLLENBQUMsY0FBYyxRQUFRLFlBQVksQ0FBQyxFQUFFLENBQUMsQ0FBQTtRQUN4RCxDQUFDO0lBQ0gsQ0FBQztJQUVELE9BQU8sR0FBRyxDQUFBO0FBQ1osQ0FBQyJ9

package/dist/deps/misc/constructs.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Checks, at compile time, that a certain situation cannot happen (and fail the build if it can). This is useful for
+ * checking that all possible cases of a union type are handled.
+ *
+ * Typical usage pattern:
+ *
+ *   type X = 'A' | 'B'
+ *
+ *   function f(x: X) {
+ *     if (x === 'a') {
+ *       // do something ...
+ *       return
+ *     }
+ *     if (x === 'b') {
+ *       // do something ...
+ *       return
+ *     }
+ *     shouldNeverHappen(x)
+ *   }
+ *
+ *
+ * If we ever change X such that it has a third case (as in `type X = 'A' | 'B' | 'C') we will get a compile error
+ * unless we add logic to this function (`f()`) to handle it.
+ *
+ * @param n a value of type `never`
+ */
+export declare function shouldNeverHappen(n: never): never;
+/**
+ * An always-failing function. If it ever gets called, it will throw an error. It is useful in conditional expressions
+ * in which one of the branches of the expression is the happy path, and the other branch is a sad path in which no
+ * value can be computed. Sepcifically, it usually appears as the right-hand-side operand of `??` or `||` expressions.
+ *
+ * Typical usage pattern:
+ *
+ *    const dir: string = process.env['WORKING_DIR'] || failMe('missing env variable "a"')
+ *
+ * Essentially, this is a concise alternative to:
+ *
+ *    const dir = process.env['a']
+ *    if (!dir) {
+ *      throw new Error('missing env variable "a"')
+ *    }
+ *
+ * @param hint an optional human-readable string to be placed in the message of the thrown error
+ */
+export declare function failMe(hint?: string): never;
+/**
+ * Evaluates just one of several functions (the `cases` parameter) based on the `selector` value passed in.
+ * `cases` is a record of zero-argument functions. The function at `cases[selector]` will be evaluated and its return
+ * value is returned back to the caller.
+ *
+ * A compile time error is produced if not all possible values of `selector` are covered by `cases`.
+ *
+ * Example:
+ *    function f(op: '+' | '-' | '*', n1: number, n2: number) {
+ *      return switchOn(op, {
+ *        '+': () => n1 + n2,
+ *        '-': () => n1 - n2,
+ *        '*': () => n1 * n2,
+ *      })
+ *    }
+ *
+ *
+ * The following snippet yields a compile-time error:
+ *
+ *    function f(op: '+' | '-' | '*', n1: number, n2: number) {
+ *      return switchOn(op, {
+ *        '+': () => n1 + n2,
+ *        '-': () => n1 - n2,
+ *      })   // <-- Compiler error here due to missing case ('*')
+ *    }
+ *
+ * And so does this:
+ *
+ *    function f(op: '+' | '-' | '*', n1: number, n2: number) {
+ *      return switchOn(op, {
+ *        '+': () => n1 + n2,
+ *        '-': () => n1 - n2,
+ *        '*': () => n1 - n2,
+ *        '/': () => n1 / n2,
+ *      })   // <-- Compiler error here due to extraneous case ('/')
+ *    }
+ *
+ * @param selector
+ * @param cases
+ * @returns
+ */
+export declare function switchOn<G, K extends string>(selector: K, cases: Record<K, () => G>): G;
+/**
+ * Safely converts an input of type `unknown` into an Error like object. The return value will contain `message`
+ * and `stack` properties which will be strings (if a corresponding propertiy of type string exists on the input) or
+ * undefined (otherwise)
+ *
+ * @param err an input of type `unknown`
+ * @returns an Error like object
+ */
+export declare function errorLike(err: unknown): {
+    message: string | undefined;
+    stack: string | undefined;
+};
+/**
+ * Generates a two-tuple from the arguments passed in. Useful in situations where the compiler fails to infer that
+ * `[foo, bar]` is a tuple and treats it like an array. Using `pair(foo, bar)` will make the compiler correctly infer
+ * the tuple type.
+ */
+export declare function pair<A, B>(a: A, b: B): [A, B];

package/dist/deps/misc/constructs.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldNeverHappen = shouldNeverHappen;
+exports.failMe = failMe;
+exports.switchOn = switchOn;
+exports.errorLike = errorLike;
+exports.pair = pair;
+/**
+ * Checks, at compile time, that a certain situation cannot happen (and fail the build if it can). This is useful for
+ * checking that all possible cases of a union type are handled.
+ *
+ * Typical usage pattern:
+ *
+ *   type X = 'A' | 'B'
+ *
+ *   function f(x: X) {
+ *     if (x === 'a') {
+ *       // do something ...
+ *       return
+ *     }
+ *     if (x === 'b') {
+ *       // do something ...
+ *       return
+ *     }
+ *     shouldNeverHappen(x)
+ *   }
+ *
+ *
+ * If we ever change X such that it has a third case (as in `type X = 'A' | 'B' | 'C') we will get a compile error
+ * unless we add logic to this function (`f()`) to handle it.
+ *
+ * @param n a value of type `never`
+ */
+function shouldNeverHappen(n) {
+    // This following line never gets executed. It is here just to make the compiler happy.
+    throw new Error(`This should never happen ${n}`);
+}
+/**
+ * An always-failing function. If it ever gets called, it will throw an error. It is useful in conditional expressions
+ * in which one of the branches of the expression is the happy path, and the other branch is a sad path in which no
+ * value can be computed. Sepcifically, it usually appears as the right-hand-side operand of `??` or `||` expressions.
+ *
+ * Typical usage pattern:
+ *
+ *    const dir: string = process.env['WORKING_DIR'] || failMe('missing env variable "a"')
+ *
+ * Essentially, this is a concise alternative to:
+ *
+ *    const dir = process.env['a']
+ *    if (!dir) {
+ *      throw new Error('missing env variable "a"')
+ *    }
+ *
+ * @param hint an optional human-readable string to be placed in the message of the thrown error
+ */
+function failMe(hint) {
+    if (!hint) {
+        throw new Error(`This expression must never be evaluated`);
+    }
+    throw new Error(`Bad value: ${hint}`);
+}
+/**
+ * Evaluates just one of several functions (the `cases` parameter) based on the `selector` value passed in.
+ * `cases` is a record of zero-argument functions. The function at `cases[selector]` will be evaluated and its return
+ * value is returned back to the caller.
+ *
+ * A compile time error is produced if not all possible values of `selector` are covered by `cases`.
+ *
+ * Example:
+ *    function f(op: '+' | '-' | '*', n1: number, n2: number) {
+ *      return switchOn(op, {
+ *        '+': () => n1 + n2,
+ *        '-': () => n1 - n2,
+ *        '*': () => n1 * n2,
+ *      })
+ *    }
+ *
+ *
+ * The following snippet yields a compile-time error:
+ *
+ *    function f(op: '+' | '-' | '*', n1: number, n2: number) {
+ *      return switchOn(op, {
+ *        '+': () => n1 + n2,
+ *        '-': () => n1 - n2,
+ *      })   // <-- Compiler error here due to missing case ('*')
+ *    }
+ *
+ * And so does this:
+ *
+ *    function f(op: '+' | '-' | '*', n1: number, n2: number) {
+ *      return switchOn(op, {
+ *        '+': () => n1 + n2,
+ *        '-': () => n1 - n2,
+ *        '*': () => n1 - n2,
+ *        '/': () => n1 / n2,
+ *      })   // <-- Compiler error here due to extraneous case ('/')
+ *    }
+ *
+ * @param selector
+ * @param cases
+ * @returns
+ */
+function switchOn(selector, cases) {
+    const f = cases[selector];
+    return f();
+}
+/**
+ * Safely converts an input of type `unknown` into an Error like object. The return value will contain `message`
+ * and `stack` properties which will be strings (if a corresponding propertiy of type string exists on the input) or
+ * undefined (otherwise)
+ *
+ * @param err an input of type `unknown`
+ * @returns an Error like object
+ */
+function errorLike(err) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const { message, stack } = err;
+    return {
+        message: typeof message === 'string' ? message : undefined,
+        stack: typeof stack === 'string' ? stack : undefined,
+    };
+}
+/**
+ * Generates a two-tuple from the arguments passed in. Useful in situations where the compiler fails to infer that
+ * `[foo, bar]` is a tuple and treats it like an array. Using `pair(foo, bar)` will make the compiler correctly infer
+ * the tuple type.
+ */
+function pair(a, b) {
+    return [a, b];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RydWN0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25zdHJ1Y3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBMEJBLDhDQUdDO0FBb0JELHdCQU1DO0FBMkNELDRCQUdDO0FBVUQsOEJBT0M7QUFPRCxvQkFFQztBQS9IRDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXlCRztBQUNILFNBQWdCLGlCQUFpQixDQUFDLENBQVE7SUFDeEMsdUZBQXVGO0lBQ3ZGLE1BQU0sSUFBSSxLQUFLLENBQUMsNEJBQTRCLENBQUMsRUFBRSxDQUFDLENBQUE7QUFDbEQsQ0FBQztBQUVEOzs7Ozs7Ozs7Ozs7Ozs7OztHQWlCRztBQUNILFNBQWdCLE1BQU0sQ0FBQyxJQUFhO0lBQ2xDLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNWLE1BQU0sSUFBSSxLQUFLLENBQUMseUNBQXlDLENBQUMsQ0FBQTtJQUM1RCxDQUFDO0lBRUQsTUFBTSxJQUFJLEtBQUssQ0FBQyxjQUFjLElBQUksRUFBRSxDQUFDLENBQUE7QUFDdkMsQ0FBQztBQUVEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBd0NHO0FBQ0gsU0FBZ0IsUUFBUSxDQUFzQixRQUFXLEVBQUUsS0FBeUI7SUFDbEYsTUFBTSxDQUFDLEdBQUcsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFBO0lBQ3pCLE9BQU8sQ0FBQyxFQUFFLENBQUE7QUFDWixDQUFDO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILFNBQWdCLFNBQVMsQ0FBQyxHQUFZO0lBQ3BDLHlFQUF5RTtJQUN6RSxNQUFNLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxHQUFHLEdBQTZDLENBQUE7SUFDeEUsT0FBTztRQUNMLE9BQU8sRUFBRSxPQUFPLE9BQU8sS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsU0FBUztRQUMxRCxLQUFLLEVBQUUsT0FBTyxLQUFLLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLFNBQVM7S0FDckQsQ0FBQTtBQUNILENBQUM7QUFFRDs7OztHQUlHO0FBQ0gsU0FBZ0IsSUFBSSxDQUFPLENBQUksRUFBRSxDQUFJO0lBQ25DLE9BQU8sQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUE7QUFDZixDQUFDIn0=

package/dist/deps/misc/directory-scanner.d.ts

@@ -0,0 +1,49 @@
+import * as fs from 'fs';
+type Predicate = (relativePath: string, stat: fs.Stats) => boolean;
+interface Options {
+    predicate?: Predicate;
+    startingPointMustExist?: boolean;
+}
+interface ListPathsOptions {
+    startingPointMustExist?: boolean;
+}
+interface ConstructorOptions {
+    predicate?: Predicate;
+}
+type ScanTreeCallback = (relativePath: string, content: Buffer, stat: fs.Stats) => void;
+type RelativePath = string;
+export declare class DirectoryScanner {
+    readonly rootDir: string;
+    private readonly options;
+    constructor(rootDir: string, options?: ConstructorOptions);
+    isValid(relativePath: string, stat: fs.Stats): boolean;
+    /**
+     * Iterates over all the files located under `startingPoint` and calls `cb` for each file.
+     * @param startingPoint a relative path to start scanning files at. It is resolved to an absolute path by joining it
+     * to the root-dir value passed to the constructor. Trailing path separators are omitted (i.e. `'a/b///'` is
+     * equivalent to `'a/b'`).
+     * @param cb
+     */
+    scanTree(startingPoint: RelativePath, cb: ScanTreeCallback): Promise<void>;
+    scanTree(startingPoint: RelativePath, options: Options, cb: ScanTreeCallback): Promise<void>;
+    /**
+     * Recursively scans a file tree, returning relative paths to all files.
+     * @param startingPoint a relative path to start scanning files at. It is resolved to an absolute path by joining it
+     * to the root-dir value passed to the constructor. Trailing path separators are omitted (i.e. `'a/b///'` is
+     * equivalent to `'a/b'`).
+     * @returns an array of relative paths (relative from the `root` path  passed to the constructor)
+     */
+    listPaths(startingPoint: RelativePath, options?: ListPathsOptions): Promise<string[]>;
+    /**
+     * Returns relative paths to all files at the file tree rooted at the given directory.
+     * @param dir directory to scan files under
+     * @returns an array of relative paths (relative to `dir`)
+     */
+    static listPaths(dir: string, options?: ListPathsOptions): Promise<string[]>;
+    private scanTreeImpl;
+    private scanFileTree;
+    private readContent;
+    private readDirSorted;
+    private getStat;
+}
+export {};