libram 0.8.27 → 0.8.28

package/dist/session.js

@@ -1,284 +0,0 @@
-import { todayToString, myName, bufferToFile, fileToBuffer, mySessionItems, mySessionMeat, toItem, getCampground, getCloset, getDisplay, getStorage, myClosetMeat, myStorageMeat, totalTurnsPlayed, } from "kolmafia";
-import { getFoldGroup } from "./lib";
-import { $item, $items } from "./template-string";
-import { sum } from "./utils";
-/**
- * Return a mapping of the session items, mapping foldable items to a single of their forms
- *
- * @param sessionOnly should closet, DC, and storage be ignored for the session calculation
- * @returns the item session results, with foldables mapped to a single of their folding forms
- */
-function mySessionItemsWrapper(sessionOnly = false) {
-    const manyToOne = (primary, mapped) => mapped.map((target) => [target, primary]);
-    const foldable = (item) => manyToOne(item, getFoldGroup(item));
-    const itemMappings = new Map([
-        ...foldable($item `liar's pants`),
-        ...foldable($item `ice pick`),
-        ...manyToOne($item `Spooky Putty sheet`, [
-            $item `Spooky Putty monster`,
-            ...getFoldGroup($item `Spooky Putty sheet`),
-        ]),
-        ...foldable($item `stinky cheese sword`),
-        ...foldable($item `naughty paper shuriken`),
-        ...foldable($item `Loathing Legion knife`),
-        ...foldable($item `deceased crimbo tree`),
-        ...foldable($item `makeshift turban`),
-        ...foldable($item `turtle wax shield`),
-        ...foldable($item `metallic foil bow`),
-        ...foldable($item `ironic moustache`),
-        ...foldable($item `bugged balaclava`),
-        ...foldable($item `toggle switch (Bartend)`),
-        ...foldable($item `mushroom cap`),
-        ...manyToOne($item `can of Rain-Doh`, $items `empty Rain-Doh can`),
-        ...manyToOne($item `meteorite fragment`, $items `meteorite earring, meteorite necklace, meteorite ring`),
-        ...manyToOne($item `Sneaky Pete's leather jacket`, $items `Sneaky Pete's leather jacket (collar popped)`),
-        ...manyToOne($item `Boris's Helm`, $items `Boris's Helm (askew)`),
-        ...manyToOne($item `Jarlsberg's pan`, $items `Jarlsberg's pan (Cosmic portal mode)`),
-        ...manyToOne($item `tiny plastic sword`, $items `grogtini, bodyslam, dirty martini, vesper, cherry bomb, sangria del diablo`),
-        ...manyToOne($item `earthenware muffin tin`, $items `blueberry muffin, bran muffin, chocolate chip muffin`),
-        ...manyToOne($item `ChibiBuddy™ (on)`, $items `ChibiBuddy™ (off)`),
-    ]);
-    const inventory = new Map();
-    const invLocations = sessionOnly
-        ? [mySessionItems]
-        : [mySessionItems, getCloset, getDisplay, getStorage];
-    if (!sessionOnly) {
-        for (const [itemStr, quantity] of Object.entries(getCampground())) {
-            if (!quantity)
-                continue;
-            const item = toItem(itemStr);
-            if (item === $item `big rock`)
-                continue; // Used to represent an empty house slot
-            const mappedItem = itemMappings.get(item) ?? item;
-            inventory.set(mappedItem, quantity + (inventory.get(mappedItem) ?? 0));
-        }
-    }
-    for (const inventoryFunc of invLocations) {
-        for (const [itemStr, quantity] of Object.entries(inventoryFunc())) {
-            if (!quantity)
-                continue;
-            const item = toItem(itemStr);
-            const mappedItem = itemMappings.get(item) ?? item;
-            inventory.set(mappedItem, quantity + (inventory.get(mappedItem) ?? 0));
-            if (inventory.get(mappedItem) === 0)
-                inventory.delete(mappedItem);
-        }
-    }
-    return inventory;
-}
-/**
- * Perform a binary element-wise operation on two inventories
- *
- * @param a The LHS inventory to perform the operation on
- * @param b The RHS inventory to perform the operation on
- * @param op an operator to compute between the sets
- * @returns a new map representing the combined inventories
- */
-function inventoryOperation(a, b, op) {
-    // return every entry that is in a and not in b
-    const difference = new Map();
-    for (const item of new Set([...a.keys(), ...b.keys()])) {
-        difference.set(item, op(a.get(item) ?? 0, b.get(item) ?? 0));
-    }
-    const diffEntries = [...difference.entries()];
-    return new Map(diffEntries.filter(([, value]) => value !== 0));
-}
-/**
- * A wrapper around tracking items and meat gained from this session
- * Smartly handles foldables being added/removed based on their state
- * Provides operations to add sessions and subtract Sessions so you can isolate the value of each Session using a baseline
- *
- * @member meat the raw meat associated with this Session
- * @member items a map representing the items gained/lost during this Session
- */
-export class Session {
-    meat;
-    items;
-    totalTurns;
-    /**
-     * Construct a new session
-     *
-     * @param meat the amount of meat associated with this session
-     * @param items the items associated with this session
-     * @param totalTurns the number of turns associated with this session
-     */
-    constructor(meat, items, totalTurns) {
-        this.meat = meat;
-        this.items = items;
-        this.totalTurns = totalTurns;
-    }
-    /**
-     * Register session results that do not get tracked natively
-     *
-     * @param target either the Item or a string saying "meat" of what quantity to modify
-     * @param quantity How much to modify the tracked amount by
-     */
-    register(target, quantity) {
-        if (target === "meat") {
-            this.meat += quantity;
-        }
-        else {
-            this.items.set(target, (this.items.get(target) ?? 0) + quantity);
-        }
-    }
-    /**
-     * Value this session
-     *
-     * @param itemValue a function that, when given an item, will give a meat value of the item
-     * @returns ItemResult with the full value of this session given the input function
-     */
-    value(itemValue) {
-        // TODO: add garbo specific pricing (sugar equipment for synth, etc.)
-        const turns = this.totalTurns;
-        const meat = Math.floor(this.meat);
-        const itemDetails = [...this.items.entries()].map(([item, quantity]) => {
-            return {
-                item,
-                quantity,
-                // only run itemValue if quantity is nonzero
-                value: quantity ? itemValue(item) * quantity : 0,
-            };
-        });
-        const items = Math.floor(sum(itemDetails, "value"));
-        return { meat, items, total: meat + items, itemDetails, turns };
-    }
-    /**
-     * Subtract the contents of another session from this one, removing any items that have a resulting quantity of 0
-     *  (this will ignore elements in b but not in a)
-     *
-     * @param other the session from which to pull values to remove from this session
-     * @returns a new session representing the difference between this session and the other session
-     */
-    diff(other) {
-        return new Session(this.meat - other.meat, inventoryOperation(this.items, other.items, (a, b) => a - b), this.totalTurns - other.totalTurns);
-    }
-    /**
-     * Subtract the contents of snasphot b from session a, removing any items that have a resulting quantity of 0
-     *  (this will ignore elements in b but not in a)
-     *
-     * @param a the session from which to subtract elements
-     * @param b the session from which to add elements
-     * @returns a new session representing the difference between a and b
-     */
-    static diff(a, b) {
-        return a.diff(b);
-    }
-    /**
-     * Generate a new session combining multiple sessions together
-     *
-     * @param other the session from which to add elements to this set
-     * @returns a new session representing the addition of other to this
-     */
-    add(other) {
-        return new Session(this.meat + other.meat, inventoryOperation(this.items, other.items, (a, b) => a + b), this.totalTurns + other.totalTurns);
-    }
-    /**
-     * Combine the contents of sessions
-     *
-     * @param sessions the set of sessions to combine together
-     * @returns a new session representing the difference between a and b
-     */
-    static add(...sessions) {
-        return sessions.reduce((previousSession, currentSession) => previousSession.add(currentSession));
-    }
-    static getFilepath(filename) {
-        return filename.endsWith(".json")
-            ? filename
-            : `snapshots/${myName()}/${todayToString()}_${filename}.json`;
-    }
-    /**
-     * Export this session to a file in the data/ directory. Conventionally this file should end in ".json"
-     *
-     * @param filename The file into which to export
-     */
-    toFile(filename) {
-        const val = {
-            meat: this.meat,
-            items: Object.fromEntries(this.items),
-            totalTurns: this.totalTurns,
-        };
-        bufferToFile(JSON.stringify(val), Session.getFilepath(filename));
-    }
-    /**
-     * Import a session from a file in the data/ directory. Conventionally the file should end in ".json"
-     *
-     * @param filename The file from which to import
-     * @returns the session represented by the file
-     */
-    static fromFile(filename) {
-        const fileValue = fileToBuffer(Session.getFilepath(filename));
-        // fileToBuffer returns empty string for files that don't exist
-        if (fileValue.length > 0) {
-            const val = JSON.parse(fileValue);
-            const parsedItems = Object.entries(val.items).map(([itemStr, quantity]) => [toItem(itemStr), quantity]);
-            return new Session(val.meat, new Map(parsedItems), val.totalTurns ?? 0);
-        }
-        else {
-            // if the file does not exist, return an empty session
-            return new Session(0, new Map(), 0);
-        }
-    }
-    /**
-     * Return the meat and items for the current session
-     *
-     * @param sessionOnly should closet, DC, and storage be ignored for the session calculation
-     * @returns current session
-     */
-    static current(sessionOnly = false) {
-        const meat = sessionOnly
-            ? [mySessionMeat]
-            : [mySessionMeat, myClosetMeat, myStorageMeat];
-        return new Session(sum(meat, (f) => f()), mySessionItemsWrapper(sessionOnly), totalTurnsPlayed());
-    }
-    /**
-     * @param baseline the base session to use when computing MPA
-     * @param full the full session to use when computing MPA
-     * @param options options for computing MPA
-     * @param options.value a function to compute the meat value of a given item
-     * @param options.isOutlier a function to compute if an item is considered an outlier. By default, no items are outliers
-     * @param options.excludeValue meat values to exclude when calculating specific portions of the MPA
-     * @param options.excludeValue.meat how much meat to exclude when calculating the meat portion of MPA
-     * @param options.excludeValue.item how much meat to exclude when calculating hte item portion of MPA
-     * @returns an analysis of the effective MPA for the given session
-     */
-    static computeMPA(baseline, full, options) {
-        const value = options.value;
-        const excludeValue = options.excludeValue ?? { meat: 0, item: 0 };
-        const isOutlier = options.isOutlier;
-        const result = full.diff(baseline).value(value);
-        const meatValue = result.meat - (excludeValue.meat ?? 0);
-        const outlierItems = isOutlier ? result.itemDetails.filter(isOutlier) : [];
-        const outliersValue = sum(outlierItems, (detail) => detail.value);
-        const itemValue = result.items - outliersValue - (excludeValue.item ?? 0);
-        const { turns } = result;
-        return {
-            mpa: {
-                effective: (meatValue + itemValue) / turns,
-                total: (meatValue + itemValue + outliersValue) / turns,
-                meat: meatValue / turns,
-                items: itemValue / turns,
-            },
-            values: {
-                effective: meatValue + itemValue,
-                total: meatValue + itemValue + outliersValue,
-                meat: meatValue,
-                items: itemValue,
-            },
-            outlierItems: outlierItems,
-            turns: turns,
-        };
-    }
-    /**
-     * @param other the session to diff against this session when computing MPA
-     * @param options options for computing MPA
-     * @param options.value a function to compute the meat value of a given item
-     * @param options.isOutlier a function to compute if an item is considered an outlier. By default, no items are outliers
-     * @param options.excludeValue meat values to exclude when calculating specific portions of the MPA
-     * @param options.excludeValue.meat how much meat to exclude when calculating the meat portion of MPA
-     * @param options.excludeValue.item how much meat to exclude when calculating hte item portion of MPA
-     * @returns an analysis of the effective MPA for the given session
-     */
-    computeMPA(other, options) {
-        return Session.computeMPA(this, other, options);
-    }
-}

package/dist/since.d.ts

@@ -1,51 +0,0 @@
-/**
- * Provides functions for checking KoLmafia's version and revision.
- *
- * @packageDocumentation
- */
-/**
- * Represents an exception thrown when the current KoLmafia version does not
- * match an expected condition.
- */
-export declare class KolmafiaVersionError extends Error {
-    constructor(message?: string);
-}
-/**
- * If KoLmafia's revision number is less than `revision`, throws an exception.
- * Otherwise, does nothing.
- *
- * This behaves like the `since rXXX;` statement in ASH.
- *
- * @param revision Revision number
- * @throws {KolmafiaVersionError}
- *    If KoLmafia's revision number is less than `revision`.
- * @throws {TypeError} If `revision` is not an integer
- * @example
- * ```ts
- * // Throws if KoLmafia revision is less than r20500
- * sinceKolmafiaRevision(20500);
- * ```
- */
-export declare function sinceKolmafiaRevision(revision: number): void;
-/**
- * If KoLmafia's version is less than `majorVersion.minorVersion`, throws an
- * exception.
- * Otherwise, does nothing.
- *
- * This behaves like the `since X.Y;` statement in ASH.
- *
- * @param majorVersion Major version number
- * @param minorVersion Minor version number
- * @deprecated Point versions are no longer released by KoLmafia
- * @throws {KolmafiaVersionError}
- *    If KoLmafia's major version is less than `majorVersion`, or if the major
- *    versions are equal but the minor version is less than `minorVersion`
- * @throws {TypeError}
- *    If either `majorVersion` or `minorVersion` are not integers
- * @example
- * ```ts
- * // Throws if KoLmafia version is less than 20.7
- * sinceKolmafiaVersion(20, 7);
- * ```
- */
-export declare function sinceKolmafiaVersion(majorVersion: number, minorVersion: number): void;

package/dist/since.js

@@ -1,108 +0,0 @@
-/**
- * Provides functions for checking KoLmafia's version and revision.
- *
- * @packageDocumentation
- */
-import { getRevision, getVersion } from "kolmafia";
-/**
- * Represents an exception thrown when the current KoLmafia version does not
- * match an expected condition.
- */
-export class KolmafiaVersionError extends Error {
-    constructor(message) {
-        super(message);
-        // Explicitly set the prototype, so that 'instanceof' still works in Node.js
-        // even when the class is transpiled down to ES5
-        // See: https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
-        // Note that this code isn't needed for Rhino.
-        Object.setPrototypeOf(this, KolmafiaVersionError.prototype);
-    }
-}
-// Manually set class name, so that the stack trace shows proper name in Rhino
-KolmafiaVersionError.prototype.name = "KolmafiaVersionError";
-/**
- * Returns the currently executing script name, suitable for embedding in an
- * error message.
- *
- * @returns Path of the main script wrapped in single-quotes, or `"This script"`
- *    if the path cannot be determined
- */
-function getScriptName() {
-    // In Rhino, the current script name is available in require.main.id
-    const scriptName = require.main?.id;
-    return scriptName ? `'${scriptName}'` : "This script";
-}
-/**
- * If KoLmafia's revision number is less than `revision`, throws an exception.
- * Otherwise, does nothing.
- *
- * This behaves like the `since rXXX;` statement in ASH.
- *
- * @param revision Revision number
- * @throws {KolmafiaVersionError}
- *    If KoLmafia's revision number is less than `revision`.
- * @throws {TypeError} If `revision` is not an integer
- * @example
- * ```ts
- * // Throws if KoLmafia revision is less than r20500
- * sinceKolmafiaRevision(20500);
- * ```
- */
-export function sinceKolmafiaRevision(revision) {
-    if (!Number.isInteger(revision)) {
-        throw new TypeError(`Invalid revision number ${revision} (must be an integer)`);
-    }
-    // Based on net.sourceforge.kolmafia.textui.Parser.sinceException()
-    const currentRevision = getRevision();
-    if (currentRevision > 0 && currentRevision < revision) {
-        throw new KolmafiaVersionError(`${getScriptName()} requires revision r${revision} of kolmafia or higher (current: ${getRevision()}). Up-to-date builds can be found at https://ci.kolmafia.us/.`);
-    }
-}
-/**
- * If KoLmafia's version is less than `majorVersion.minorVersion`, throws an
- * exception.
- * Otherwise, does nothing.
- *
- * This behaves like the `since X.Y;` statement in ASH.
- *
- * @param majorVersion Major version number
- * @param minorVersion Minor version number
- * @deprecated Point versions are no longer released by KoLmafia
- * @throws {KolmafiaVersionError}
- *    If KoLmafia's major version is less than `majorVersion`, or if the major
- *    versions are equal but the minor version is less than `minorVersion`
- * @throws {TypeError}
- *    If either `majorVersion` or `minorVersion` are not integers
- * @example
- * ```ts
- * // Throws if KoLmafia version is less than 20.7
- * sinceKolmafiaVersion(20, 7);
- * ```
- */
-export function sinceKolmafiaVersion(majorVersion, minorVersion) {
-    if (getRevision() >= 25720) {
-        return;
-    }
-    if (!Number.isInteger(majorVersion)) {
-        throw new TypeError(`Invalid major version number ${majorVersion} (must be an integer)`);
-    }
-    if (!Number.isInteger(minorVersion)) {
-        throw new TypeError(`Invalid minor version number ${minorVersion} (must be an integer)`);
-    }
-    if (majorVersion > 21 || (majorVersion === 20 && minorVersion > 9)) {
-        throw new Error(`There were no versions released after 21.09. This command will always fail`);
-    }
-    const versionStr = getVersion();
-    const versionStrMatch = /v(\d+)\.(\d+)/.exec(versionStr);
-    if (!versionStrMatch) {
-        // This is not something the user should handle
-        throw new Error(`Unexpected KoLmafia version string: "${versionStr}". You may need to update the script.`);
-    }
-    const currentMajorVersion = Number(versionStrMatch[1]);
-    const currentMinorVersion = Number(versionStrMatch[2]);
-    // Based on net.sourceforge.kolmafia.textui.Parser.sinceException()
-    if (currentMajorVersion < majorVersion ||
-        (currentMajorVersion === majorVersion && currentMinorVersion < minorVersion)) {
-        throw new KolmafiaVersionError(`${getScriptName()} requires version ${majorVersion}.${minorVersion} of kolmafia or higher (current: ${currentMajorVersion}.${currentMinorVersion}). Up-to-date builds can be found at https://ci.kolmafia.us/.`);
-    }
-}