libram 0.8.28 → 0.8.29

package/dist/console.d.ts

@@ -0,0 +1,12 @@
+export declare const log: (...args: {
+    toString(): string;
+}[]) => void;
+export declare const info: (...args: {
+    toString(): string;
+}[]) => void;
+export declare const warn: (...args: {
+    toString(): string;
+}[]) => void;
+export declare const error: (...args: {
+    toString(): string;
+}[]) => void;

package/dist/console.js

@@ -0,0 +1,14 @@
+import { print } from "kolmafia";
+const logColor = (color) => (...args) => {
+    const output = args.map((x) => x.toString()).join(" ");
+    if (color) {
+        print(output, color);
+    }
+    else {
+        print(output);
+    }
+};
+export const log = logColor();
+export const info = logColor("blue");
+export const warn = logColor("red");
+export const error = logColor("red");

package/dist/counter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns Infinity for counters that do not exist, and otherwise returns the duration of the counter
+ *
+ * @param counter The name of the counter in question
+ * @returns Infinity if the counter does not exist; otherwise returns the duration of the counter
+ */
+export declare function get(counter: string): number;
+/**
+ * The world is everything that is the case. This determines which counters are the case.
+ *
+ * @param counter The name of the counter in question
+ * @returns True for counters which currently exist; false for those which do not
+ */
+export declare function exists(counter: string): boolean;
+/**
+ * Creates a manual counter with specified name and duration
+ *
+ * @param counter Name of the counter to manually create
+ * @param duration Duration of counter to manually set
+ * @returns Whether the counter was successfully set
+ */
+export declare function set(counter: string, duration: number): boolean;

package/dist/counter.js

@@ -0,0 +1,37 @@
+import { cliExecute, getCounter, getCounters } from "kolmafia";
+/**
+ * Returns Infinity for counters that do not exist, and otherwise returns the duration of the counter
+ *
+ * @param counter The name of the counter in question
+ * @returns Infinity if the counter does not exist; otherwise returns the duration of the counter
+ */
+export function get(counter) {
+    const value = getCounter(counter);
+    // getCounter returns -1 for counters that don't exist, but it also returns -1 for counters whose value is -1
+    if (value === -1) {
+        // if we have a counter with value -1, we check to see if that counter exists via getCounters()
+        // We return null if it doesn't exist
+        return getCounters(counter, -1, -1).trim() === "" ? Infinity : -1;
+    }
+    return value;
+}
+/**
+ * The world is everything that is the case. This determines which counters are the case.
+ *
+ * @param counter The name of the counter in question
+ * @returns True for counters which currently exist; false for those which do not
+ */
+export function exists(counter) {
+    return (getCounter(counter) !== -1 || getCounters(counter, -1, -1).trim() !== "");
+}
+/**
+ * Creates a manual counter with specified name and duration
+ *
+ * @param counter Name of the counter to manually create
+ * @param duration Duration of counter to manually set
+ * @returns Whether the counter was successfully set
+ */
+export function set(counter, duration) {
+    cliExecute(`counters add ${duration} ${counter}`);
+    return get(counter) !== null;
+}

package/dist/diet/index.d.ts

@@ -0,0 +1,80 @@
+import { Effect, Item } from "kolmafia";
+declare type RawDietEntry<T> = [MenuItem<T>[], number];
+declare type RawDiet<T> = RawDietEntry<T>[];
+declare type MenuItemOptions<T> = Partial<{
+    organ: Organ;
+    size: number;
+    maximum: number | "auto";
+    additionalValue: number;
+    effect: Effect;
+    priceOverride: number;
+    mayo: Item;
+    data: T;
+    useRetrievePrice: boolean;
+}>;
+export declare class MenuItem<T> {
+    item: Item;
+    organ?: Organ;
+    size: number;
+    maximum?: number;
+    additionalValue?: number;
+    effect?: Effect;
+    priceOverride?: number;
+    mayo?: Item;
+    data?: T;
+    static defaultPriceFunction: (item: Item) => number;
+    static defaultOptions<T>(): Map<Item, MenuItemOptions<T>>;
+    /**
+     * Construct a new menu item, possibly with extra properties. Items in MenuItem.defaultOptions have intelligent defaults.
+     *
+     * @param item Item to add to menu.
+     * @param options Options for this menu item
+     * @param options.organ Designate item as belonging to a specific organ.
+     * @param options.size Override item organ size. Necessary for any non-food/booze/spleen item.
+     * @param options.maximum Maximum uses remaining today, or "auto" to check dailyusesleft Mafia property.
+     * @param options.additionalValue Additional value (positive) or cost (negative) to consider with item, e.g. from buffs.
+     * @param options.effect Effect associated with this menu item (pocket wish effect, sweet synthesis effect, pill keeper potion extension)
+     * @param options.mayo Which mayo to use before item (ignored if mayo clinic is not installed or item is not a food)
+     * @param options.note Any note to track information about item, to be used later
+     */
+    constructor(item: Item, options?: MenuItemOptions<T>);
+    equals(other: MenuItem<T>): boolean;
+    toString(): string;
+    price(): number;
+}
+declare const organs: readonly ["food", "booze", "spleen item"];
+declare type Organ = typeof organs[number];
+declare class DietEntry<T> {
+    readonly menuItems: MenuItem<T>[];
+    quantity: number;
+    constructor(menuItems: MenuItem<T>[], quantity: number);
+    target(): MenuItem<T>;
+    helpers(): MenuItem<T>[];
+    expectedAdventures(diet: Diet<T>): number;
+    expectedValue(mpa: number, diet: Diet<T>, method?: "gross" | "net"): number;
+    expectedPrice(): number;
+}
+interface OrganCapacity {
+    food?: number | "auto";
+    booze?: number | "auto";
+    spleen?: number | "auto";
+}
+/**
+ * A representation of a potential diet
+ */
+export declare class Diet<T> {
+    entries: DietEntry<T>[];
+    constructor(entries?: DietEntry<T>[]);
+    get refinedPalate(): boolean;
+    get garish(): boolean;
+    get saucemaven(): boolean;
+    get tuxedoShirt(): boolean;
+    get pinkyRing(): boolean;
+    expectedAdventures(): number;
+    expectedValue(mpa: number, method?: "gross" | "net"): number;
+    expectedPrice(): number;
+    copy(): Diet<T>;
+    static from<T>(rawDiet: RawDiet<T>): Diet<T>;
+    static plan<T>(mpa: number, menu: MenuItem<T>[], organCapacities?: OrganCapacity): Diet<T>;
+}
+export {};