@schedule1-tools/mixer 0.0.2 → 0.2.2

package/README.md

@@ -17,11 +17,29 @@ const result = mixSubstances('OG Kush', ['Cuke', 'Flu Medicine', 'Gasoline']);
 
 /*
 {
-  effects: [ 'Be', 'Eu', 'Se', 'To' ],
+  effects: [ 'Be', 'Se', 'Eu', 'To' ],
   cost: 12,
   sellPrice: 64,
-  profit: 17,
-  profitMargin: 0.27
+  profit: 52,
+  profitMargin: 0.81,
+  addiction: 0.44
+}
+*/
+```
+
+### Calculate a mix using a hash
+
+```typescript
+const result = mixFromHash('T0cgS3VzaDpBQkM');
+
+/*
+{
+  effects: [ 'Be', 'Se', 'Eu', 'To' ],
+  cost: 12,
+  sellPrice: 64,
+  profit: 52,
+  profitMargin: 0.81,
+  addiction: 0.44
 }
 */
 ```

package/dist/core/effectSet.d.ts

@@ -1,38 +1,38 @@
 import type { EffectCode } from '../types';
 export declare class EffectSet {
-    private static readonly effectToIndex;
-    private static readonly indexToEffect;
-    private static initialized;
-    private bits;
-    /**
-     * Initialize the static mapping between effect codes and bit positions
-     */
-    private static initialize;
+    private effects;
     constructor(initialEffects?: EffectCode[]);
     /**
      * Add an effect to the set
-     * @returns true if the effect was added, false if it was already present
+     * @param effect - The effect to add
+     * @returns True if the effect was added, false if it already exists
      */
     add(effect: EffectCode): boolean;
     /**
      * Remove an effect from the set
-     * @returns true if the effect was removed, false if it wasn't present
+     * @param effect - The effect to remove
+     * @returns True if the effect was removed, false if it didn't exist
      */
     remove(effect: EffectCode): boolean;
     /**
-     * Check if an effect is in the set
+     * Check if the set contains an effect
+     * @param effect - The effect to check for
+     * @returns True if the effect is in the set, false otherwise
      */
     has(effect: EffectCode): boolean;
     /**
-     * Convert the set to an array of effect codes
+     * Convert the set to an array
+     * @returns An array of effects
      */
     toArray(): EffectCode[];
     /**
-     * Get the number of effects in the set
+     * Get the size of the set
+     * @returns The number of effects in the set
      */
     size(): number;
     /**
-     * Create a copy of this effect set
+     * Clone the set
+     * @returns A new set with the same effects
      */
     clone(): EffectSet;
 }

package/dist/core/effectSet.js

@@ -2,132 +2,59 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EffectSet = void 0;
 class EffectSet {
-    /**
-     * Initialize the static mapping between effect codes and bit positions
-     */
-    static initialize() {
-        if (this.initialized)
-            return;
-        const effects = [
-            'Ag',
-            'At',
-            'Ba',
-            'Be',
-            'Ca',
-            'Cd',
-            'Cy',
-            'Di',
-            'El',
-            'En',
-            'Eu',
-            'Ex',
-            'Fc',
-            'Fo',
-            'Gi',
-            'Gl',
-            'Je',
-            'La',
-            'Lf',
-            'Mu',
-            'Pa',
-            'Re',
-            'Sc',
-            'Se',
-            'Sh',
-            'Si',
-            'Sl',
-            'Sm',
-            'Sn',
-            'Sp',
-            'To',
-            'Tp',
-            'Tt',
-            'Zo',
-        ];
-        effects.forEach((effect, index) => {
-            this.effectToIndex.set(effect, index);
-            this.indexToEffect.set(index, effect);
-        });
-        this.initialized = true;
-    }
     constructor(initialEffects = []) {
-        this.bits = 0;
-        EffectSet.initialize();
-        for (const effect of initialEffects) {
-            this.add(effect);
-        }
+        this.effects = new Set(initialEffects);
     }
     /**
      * Add an effect to the set
-     * @returns true if the effect was added, false if it was already present
+     * @param effect - The effect to add
+     * @returns True if the effect was added, false if it already exists
      */
     add(effect) {
-        const index = EffectSet.effectToIndex.get(effect);
-        if (index === undefined)
-            return false;
-        const mask = 1 << index;
-        const alreadyExists = (this.bits & mask) !== 0;
-        this.bits |= mask;
+        const alreadyExists = this.effects.has(effect);
+        this.effects.add(effect);
         return !alreadyExists;
     }
     /**
      * Remove an effect from the set
-     * @returns true if the effect was removed, false if it wasn't present
+     * @param effect - The effect to remove
+     * @returns True if the effect was removed, false if it didn't exist
      */
     remove(effect) {
-        const index = EffectSet.effectToIndex.get(effect);
-        if (index === undefined)
-            return false;
-        const mask = 1 << index;
-        const existed = (this.bits & mask) !== 0;
-        this.bits &= ~mask;
+        const existed = this.effects.has(effect);
+        this.effects.delete(effect);
         return existed;
     }
     /**
-     * Check if an effect is in the set
+     * Check if the set contains an effect
+     * @param effect - The effect to check for
+     * @returns True if the effect is in the set, false otherwise
      */
     has(effect) {
-        const index = EffectSet.effectToIndex.get(effect);
-        if (index === undefined)
-            return false;
-        return (this.bits & (1 << index)) !== 0;
+        return this.effects.has(effect);
     }
     /**
-     * Convert the set to an array of effect codes
+     * Convert the set to an array
+     * @returns An array of effects
      */
     toArray() {
-        const result = [];
-        for (let i = 0; i < 34; i++) {
-            if ((this.bits & (1 << i)) !== 0) {
-                const effect = EffectSet.indexToEffect.get(i);
-                if (effect)
-                    result.push(effect);
-            }
-        }
-        return result;
+        return Array.from(this.effects);
     }
     /**
-     * Get the number of effects in the set
+     * Get the size of the set
+     * @returns The number of effects in the set
      */
     size() {
-        let count = 0;
-        let n = this.bits;
-        while (n) {
-            n &= n - 1;
-            count++;
-        }
-        return count;
+        return this.effects.size;
     }
     /**
-     * Create a copy of this effect set
+     * Clone the set
+     * @returns A new set with the same effects
      */
     clone() {
         const clone = new EffectSet();
-        clone.bits = this.bits;
+        clone.effects = new Set(this.effects);
         return clone;
     }
 }
 exports.EffectSet = EffectSet;
-EffectSet.effectToIndex = new Map();
-EffectSet.indexToEffect = new Map();
-EffectSet.initialized = false;

package/dist/core/mixer.d.ts

@@ -1,5 +1,14 @@
-import type { MixResult, ProductType, SubstanceCode } from '../types';
+import type { MixResult, Product, Substance } from '../types';
 /**
  * Calculate the result of mixing substances with a product
+ * @param product - The product to mix
+ * @param substanceCodes - The substances to mix
+ * @returns The result of the mix
  */
-export declare function mixSubstances(product: ProductType, substanceCodes: SubstanceCode[]): MixResult;
+export declare function mixSubstances(product: Product, substanceCodes: Substance[]): MixResult;
+/**
+ * Mix substances from a hash
+ * @param hash - The hash to mix
+ * @returns The result of the mix
+ */
+export declare function mixFromHash(hash: string): MixResult;

package/dist/core/mixer.js

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mixSubstances = mixSubstances;
+exports.mixFromHash = mixFromHash;
 const effects_1 = require("../data/effects");
 const products_1 = require("../data/products");
 const rules_1 = require("../data/rules");
 const substances_1 = require("../data/substances");
+const encoding_1 = require("../utils/encoding");
 const effectSet_1 = require("./effectSet");
 const MAX_EFFECTS = 8;
 /**
  * Calculate the result of mixing substances with a product
+ * @param product - The product to mix
+ * @param substanceCodes - The substances to mix
+ * @returns The result of the mix
  */
 function mixSubstances(product, substanceCodes) {
     if (!products_1.products[product]) {
@@ -16,16 +21,40 @@ function mixSubstances(product, substanceCodes) {
     }
     const productInfo = products_1.products[product];
     const effectsSet = new effectSet_1.EffectSet(productInfo.effects);
-    const processedEffects = new effectSet_1.EffectSet();
-    const removedEffects = new effectSet_1.EffectSet();
     let totalCost = 0;
     for (const code of substanceCodes) {
         const substance = substances_1.substances[code];
         if (!substance)
             continue;
         totalCost += substance.price;
-        applySubstanceRules(code, effectsSet, processedEffects, removedEffects);
-        if (effectsSet.size() < MAX_EFFECTS) {
+        const rules = rules_1.effectRulesBySubstance[code];
+        if (rules && rules.length > 0) {
+            const initialEffects = effectsSet.clone();
+            const processedEffects = new effectSet_1.EffectSet();
+            const removedEffects = new effectSet_1.EffectSet();
+            const appliedRules = new Set();
+            // Phase 1: Apply rules where conditions are met in the initial state
+            for (let i = 0; i < rules.length; i++) {
+                const rule = rules[i];
+                if (checkRulePreconditions(rule, initialEffects)) {
+                    applyReplaceEffects(rule.replace, initialEffects, effectsSet, processedEffects, removedEffects);
+                    appliedRules.add(i);
+                }
+            }
+            // Phase 2: Apply rules where conditions are met after phase 1
+            for (let i = 0; i < rules.length; i++) {
+                if (appliedRules.has(i))
+                    continue;
+                const rule = rules[i];
+                if (meetsPhaseTwo(rule, initialEffects, effectsSet, removedEffects)) {
+                    if (canApplyTransformation(rule.replace, effectsSet)) {
+                        applyTransformations(rule.replace, effectsSet, processedEffects);
+                    }
+                }
+            }
+        }
+        // Add substance effects AFTER applying rules
+        if (effectsSet.size() < MAX_EFFECTS && substance.effect) {
             for (const effect of substance.effect) {
                 if (!effectsSet.has(effect)) {
                     effectsSet.add(effect);
@@ -37,9 +66,10 @@ function mixSubstances(product, substanceCodes) {
     }
     const finalEffects = effectsSet.toArray().slice(0, MAX_EFFECTS);
     const effectValue = calculateEffectValue(finalEffects);
-    const productPrice = productInfo.price;
-    const sellPrice = Math.round(productPrice * (1 + effectValue));
-    const profit = sellPrice - totalCost - productPrice;
+    const addictionValue = calculateAddiction(finalEffects);
+    const addiction = Math.round(addictionValue * 100) / 100;
+    const sellPrice = Math.round(productInfo.price * (1 + effectValue));
+    const profit = sellPrice - totalCost;
     const profitMargin = Math.round((profit / sellPrice) * 100) / 100;
     return {
         effects: finalEffects,
@@ -47,39 +77,26 @@ function mixSubstances(product, substanceCodes) {
         sellPrice,
         profit,
         profitMargin,
+        addiction,
     };
 }
 /**
- * Apply the rules for a substance to the current effect set
+ * Mix substances from a hash
+ * @param hash - The hash to mix
+ * @returns The result of the mix
  */
-function applySubstanceRules(substanceCode, effectsSet, processedEffects, removedEffects) {
-    const rules = rules_1.effectRulesBySubstance[substanceCode];
-    if (!rules || rules.length === 0)
-        return;
-    const initialEffects = effectsSet.clone();
-    const appliedRules = new Set();
-    // Phase 1: Apply rules where conditions are met in the initial state
-    for (let i = 0; i < rules.length; i++) {
-        const rule = rules[i];
-        if (checkRulePreconditions(rule, initialEffects)) {
-            applyReplaceEffects(rule.replace, initialEffects, effectsSet, processedEffects, removedEffects);
-            appliedRules.add(i);
-        }
-    }
-    // Phase 2: Apply rules where conditions are met after phase 1
-    for (let i = 0; i < rules.length; i++) {
-        if (appliedRules.has(i))
-            continue;
-        const rule = rules[i];
-        if (meetsPhaseTwo(rule, initialEffects, effectsSet, removedEffects)) {
-            if (canApplyTransformation(rule.replace, effectsSet)) {
-                applyTransformations(rule.replace, effectsSet, processedEffects);
-            }
-        }
+function mixFromHash(hash) {
+    const state = (0, encoding_1.decodeMixState)(hash);
+    if (!state) {
+        throw new Error(`Invalid hash: ${hash}`);
     }
+    return mixSubstances(state.product, state.substances);
 }
 /**
  * Check if a rule's preconditions are met
+ * @param rule - The rule to check
+ * @param initialEffects - The initial effects
+ * @returns True if the preconditions are met, false otherwise
  */
 function checkRulePreconditions(rule, initialEffects) {
     // Check if all required effects are present
@@ -101,6 +118,11 @@ function checkRulePreconditions(rule, initialEffects) {
 }
 /**
  * Check if a rule meets phase two conditions
+ * @param rule - The rule to check
+ * @param initialEffects - The initial effects
+ * @param currentEffects - The current effects
+ * @param removedEffects - The removed effects
+ * @returns True if the rule meets the conditions, false otherwise
  */
 function meetsPhaseTwo(rule, initialEffects, currentEffects, removedEffects) {
     // All required effects must have been initially present
@@ -125,18 +147,13 @@ function meetsPhaseTwo(rule, initialEffects, currentEffects, removedEffects) {
     }
     return true;
 }
-/**
- * Check if a transformation can be applied
- */
-function canApplyTransformation(replace, effectsSet) {
-    for (const oldEffect of Object.keys(replace)) {
-        if (effectsSet.has(oldEffect))
-            return true;
-    }
-    return false;
-}
 /**
  * Apply effect replacements
+ * @param replace - The replacements to apply
+ * @param initialEffects - The initial effects
+ * @param effectsSet - The effects set
+ * @param processedEffects - The processed effects
+ * @param removedEffects - The removed effects
  */
 function applyReplaceEffects(replace, initialEffects, effectsSet, processedEffects, removedEffects) {
     for (const [oldEffect, newEffect] of Object.entries(replace)) {
@@ -148,8 +165,24 @@ function applyReplaceEffects(replace, initialEffects, effectsSet, processedEffec
         }
     }
 }
+/**
+ * Check if a transformation can be applied
+ * @param replace - The replacements to apply
+ * @param effectsSet - The effects set
+ * @returns True if the transformation can be applied, false otherwise
+ */
+function canApplyTransformation(replace, effectsSet) {
+    for (const oldEffect of Object.keys(replace)) {
+        if (effectsSet.has(oldEffect))
+            return true;
+    }
+    return false;
+}
 /**
  * Apply transformations to effects
+ * @param replace - The replacements to apply
+ * @param effectsSet - The effects set
+ * @param processedEffects - The processed effects
  */
 function applyTransformations(replace, effectsSet, processedEffects) {
     for (const [oldEffect, newEffect] of Object.entries(replace)) {
@@ -162,6 +195,8 @@ function applyTransformations(replace, effectsSet, processedEffects) {
 }
 /**
  * Calculate the total value multiplier from effects
+ * @param effectCodes - The effects to calculate the value for
+ * @returns The total value multiplier
  */
 function calculateEffectValue(effectCodes) {
     var _a;
@@ -171,3 +206,16 @@ function calculateEffectValue(effectCodes) {
     }
     return value;
 }
+/**
+ * Calculate the total addiction value from effects
+ * @param effectCodes - The effects to calculate the value for
+ * @returns The total addiction value
+ */
+function calculateAddiction(effectCodes) {
+    var _a;
+    let value = 0;
+    for (const code of effectCodes) {
+        value += ((_a = effects_1.effects[code]) === null || _a === void 0 ? void 0 : _a.addiction) || 0;
+    }
+    return value;
+}

package/dist/data/effects.js

@@ -4,172 +4,274 @@ exports.effects = void 0;
 exports.effects = {
     Ca: {
         name: 'Calming',
+        description: 'Induces a slight calmness in the user.',
+        tier: 1,
         price: 0.1,
         color: '#fdba74',
+        addiction: 0,
     },
     Re: {
         name: 'Refreshing',
+        description: 'Slightly energizes the user.',
+        tier: 1,
         price: 0.14,
         color: '#bef264',
+        addiction: 0.104,
     },
     En: {
         name: 'Energizing',
+        description: 'Increases the users energy.',
+        tier: 2,
         price: 0.22,
         color: '#a3e635',
+        addiction: 0.34,
     },
     Se: {
         name: 'Sedating',
+        description: 'Induces heavy sleepiness in the user.',
+        tier: 2,
         price: 0.26,
         color: '#818cf8',
+        addiction: 0,
     },
     Be: {
         name: 'Bright-Eyed',
+        description: "Causes the user's eyes to emit light.",
+        tier: 4,
         price: 0.4,
         color: '#67e8f9',
+        addiction: 0.2,
     },
     Cd: {
         name: 'Calorie-Dense',
+        description: 'Results in immediate weight gain.',
+        tier: 2,
         price: 0.28,
         color: '#e879f9',
+        addiction: 0.1,
     },
     Eu: {
         name: 'Euphoric',
+        description: 'Induces mild euphoria in the user.',
+        tier: 1,
         price: 0.18,
         color: '#fde68a',
+        addiction: 0.235,
     },
     To: {
         name: 'Toxic',
+        description: "Damages the user's liver and induces vomiting.",
+        tier: 2,
         price: 0,
         color: '#a3e635',
+        addiction: 0,
     },
     At: {
         name: 'Athletic',
+        description: 'After consumption, the user is only able to run.',
+        tier: 3,
         price: 0.32,
         color: '#7dd3fc',
+        addiction: 0.607,
     },
     Ba: {
         name: 'Balding',
+        description: 'Causes balding in the user.',
+        tier: 3,
         price: 0.3,
         color: '#c79232',
+        addiction: 0,
     },
     Ag: {
         name: 'Anti-Gravity',
+        description: 'Weakens the effects of gravity on the user.',
+        tier: 5,
         price: 0.54,
         color: '#3b82f6',
+        addiction: 0.611,
     },
     Mu: {
         name: 'Munchies',
+        description: 'Makes the user hungry.',
+        tier: 1,
         price: 0.12,
         color: '#C96E57',
+        addiction: 0.096,
     },
     Sl: {
         name: 'Slippery',
+        description: "Reduces the user's ability to maintain traction on the ground.",
+        tier: 3,
         price: 0.34,
         color: '#7dd3fc',
+        addiction: 0.309,
     },
     Gi: {
         name: 'Gingeritis',
+        description: 'After consumption, the user will become a ginger.',
+        tier: 2,
         price: 0.2,
         color: '#fb923c',
+        addiction: 0,
     },
     Sn: {
         name: 'Sneaky',
+        description: 'Silences the users foot steps.',
+        tier: 2,
         price: 0.24,
         color: '#a8a29e',
+        addiction: 0.327,
     },
     Tp: {
         name: 'Thought-Provoking',
+        description: "Increases the size of the user's head.",
+        tier: 4,
         price: 0.44,
         color: '#f9a8d4',
+        addiction: 0.37,
     },
     Sp: {
         name: 'Spicy',
+        description: "Consumption results in the user's eyes turning blue.",
+        tier: 3,
         price: 0.38,
         color: '#f87171',
+        addiction: 0.665,
     },
     Pa: {
         name: 'Paranoia',
+        description: 'Induces paranoia in the user.',
+        tier: 1,
         price: 0,
         color: '#f87171',
+        addiction: 0,
     },
     Tt: {
         name: 'Tropic Thunder',
+        description: "Inverts the user's skin color.",
+        tier: 4,
         price: 0.46,
         color: '#fdba74',
+        addiction: 0.803,
     },
     Gl: {
         name: 'Glowing',
+        description: 'Imbues a bioluminescence on the user.',
+        tier: 4,
         price: 0.48,
         color: '#85E459',
+        addiction: 0.472,
     },
     Cy: {
         name: 'Cyclopean',
+        description: 'Causes the user to see with a single eye in the center of their forehead.',
+        tier: 5,
         price: 0.56,
         color: '#FEC174',
+        addiction: 0.1,
     },
     Fo: {
         name: 'Foggy',
+        description: 'Causes a cloud of fog to form around the user.',
+        tier: 3,
         price: 0.36,
         color: '#94a3b8',
+        addiction: 0.1,
     },
     Ex: {
         name: 'Explosive',
+        description: 'Causes the user to explode shortly after consumption.',
+        tier: 5,
         price: 0,
         color: '#ef4444',
+        addiction: 0,
     },
     La: {
         name: 'Laxative',
+        description: 'Causes the user to fart and shit uncontrollably.',
+        tier: 3,
         price: 0,
         color: '#a16207',
+        addiction: 0.1,
     },
     Lf: {
         name: 'Long Faced',
+        description: "Considerably increases the size of the user's head and neck.",
+        tier: 5,
         price: 0.52,
         color: '#fde047',
+        addiction: 0.607,
     },
     Je: {
         name: 'Jennerising',
+        description: "Inverts the user's gender.",
+        tier: 4,
         price: 0.42,
         color: '#e879f9',
+        addiction: 0.343,
     },
     El: {
         name: 'Electrifying',
+        description: 'Electrifies the user, causing arcs of electricity to be emitted, zapping anyone nearby.',
+        tier: 5,
         price: 0.5,
         color: '#22d3ee',
+        addiction: 0.235,
     },
     Di: {
         name: 'Disorienting',
+        description: 'Causes unpredictable movement and slight visual impairment in the user.',
+        tier: 2,
         price: 0,
         color: '#FE7551',
+        addiction: 0,
     },
     Sc: {
         name: 'Schizophrenia',
+        description: 'Induces hallucinations and unpredictable behaviour in the user.',
+        tier: 4,
         price: 0,
         color: '#645AFD',
+        addiction: 0,
     },
     Si: {
         name: 'Seizure-Inducing',
+        description: 'Consumption results in an instant seizure.',
+        tier: 3,
         price: 0,
         color: '#FEE900',
+        addiction: 0,
     },
     Zo: {
         name: 'Zombifying',
+        description: 'Transforms the user into a zombie, causing them to walk with a limp and seek brains.',
+        tier: 5,
         price: 0.58,
         color: '#71AB5D',
+        addiction: 0.598,
     },
     Fc: {
         name: 'Focused',
+        description: "Focuses the user's mind.",
+        tier: 1,
         price: 0.16,
         color: '#75F1FD',
+        addiction: 0.104,
     },
     Sm: {
         name: 'Smelly',
+        description: 'Makes the user unbearably smelly.',
+        tier: 1,
         price: 0,
         color: '#84cc16',
+        addiction: 0,
     },
     Sh: {
         name: 'Shrinking',
+        description: 'Shrinks the user.',
+        tier: 5,
         price: 0.6,
         color: '#B6FEDA',
+        addiction: 0.336,
     },
 };

package/dist/data/products.d.ts

@@ -1,3 +1,3 @@
-import type { ProductData, ProductType } from '../types';
-export declare const products: Record<ProductType, ProductData>;
-export declare const productAbbreviations: Record<string, ProductType>;
+import type { Product, ProductData } from '../types';
+export declare const products: Record<Product, ProductData>;
+export declare const productAbbreviations: Record<string, Product>;

package/dist/data/products.js

@@ -22,16 +22,16 @@ exports.products = {
         effects: ['Se'],
         abbreviation: 'GE',
     },
-    Cocaine: {
-        price: 150,
-        effects: [],
-        abbreviation: 'CE',
-    },
     Meth: {
         price: 70,
         effects: [],
         abbreviation: 'MH',
     },
+    Cocaine: {
+        price: 150,
+        effects: [],
+        abbreviation: 'CE',
+    },
 };
 exports.productAbbreviations = Object.entries(exports.products).reduce((acc, [product, data]) => {
     acc[data.abbreviation] = product;

package/dist/data/rules.d.ts

@@ -1,2 +1,2 @@
-import type { EffectRule, SubstanceCode } from '../types';
-export declare const effectRulesBySubstance: Record<SubstanceCode, EffectRule[]>;
+import type { EffectRule, Substance } from '../types';
+export declare const effectRulesBySubstance: Record<Substance, EffectRule[]>;

package/dist/data/substances.d.ts

@@ -1,3 +1,3 @@
-import type { SubstanceCode, SubstanceData } from '../types';
-export declare const substances: Record<SubstanceCode, SubstanceData>;
-export declare const substanceAbbreviations: Record<string, SubstanceCode>;
+import type { Substance, SubstanceData } from '../types';
+export declare const substances: Record<Substance, SubstanceData>;
+export declare const substanceAbbreviations: Record<string, Substance>;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { mixSubstances } from './core/mixer';
+export { mixSubstances, mixFromHash } from './core/mixer';
 export { encodeMixState, decodeMixState } from './utils/encoding';
 export { effects } from './data/effects';
 export { products, productAbbreviations } from './data/products';
 export { substances } from './data/substances';
 export { effectRulesBySubstance } from './data/rules';
-export type { EffectCode, SubstanceCode, ProductType, RankCode, EffectData, SubstanceData, ProductData, EffectRule, MixResult, MixState, } from './types';
+export type { EffectCode, Substance, Product, RankCode, EffectData, SubstanceData, ProductData, EffectRule, MixResult, MixState, } from './types';

package/dist/index.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.effectRulesBySubstance = exports.substances = exports.productAbbreviations = exports.products = exports.effects = exports.decodeMixState = exports.encodeMixState = exports.mixSubstances = void 0;
+exports.effectRulesBySubstance = exports.substances = exports.productAbbreviations = exports.products = exports.effects = exports.decodeMixState = exports.encodeMixState = exports.mixFromHash = exports.mixSubstances = void 0;
 // Main exports
 var mixer_1 = require("./core/mixer");
 Object.defineProperty(exports, "mixSubstances", { enumerable: true, get: function () { return mixer_1.mixSubstances; } });
+Object.defineProperty(exports, "mixFromHash", { enumerable: true, get: function () { return mixer_1.mixFromHash; } });
 var encoding_1 = require("./utils/encoding");
 Object.defineProperty(exports, "encodeMixState", { enumerable: true, get: function () { return encoding_1.encodeMixState; } });
 Object.defineProperty(exports, "decodeMixState", { enumerable: true, get: function () { return encoding_1.decodeMixState; } });

package/dist/types.d.ts

@@ -1,11 +1,14 @@
 export type EffectCode = 'Ag' | 'At' | 'Ba' | 'Be' | 'Ca' | 'Cd' | 'Cy' | 'Di' | 'El' | 'En' | 'Eu' | 'Ex' | 'Fc' | 'Fo' | 'Gi' | 'Gl' | 'Je' | 'La' | 'Lf' | 'Mu' | 'Pa' | 'Re' | 'Sc' | 'Se' | 'Sh' | 'Si' | 'Sl' | 'Sm' | 'Sn' | 'Sp' | 'To' | 'Tp' | 'Tt' | 'Zo';
-export type SubstanceCode = 'Cuke' | 'Flu Medicine' | 'Gasoline' | 'Donut' | 'Energy Drink' | 'Mouth Wash' | 'Motor Oil' | 'Banana' | 'Chili' | 'Iodine' | 'Paracetamol' | 'Viagra' | 'Horse Semen' | 'Mega Bean' | 'Addy' | 'Battery';
-export type ProductType = 'OG Kush' | 'Sour Diesel' | 'Green Crack' | 'Grandaddy Purple' | 'Meth' | 'Cocaine';
+export type Substance = 'Cuke' | 'Flu Medicine' | 'Gasoline' | 'Donut' | 'Energy Drink' | 'Mouth Wash' | 'Motor Oil' | 'Banana' | 'Chili' | 'Iodine' | 'Paracetamol' | 'Viagra' | 'Horse Semen' | 'Mega Bean' | 'Addy' | 'Battery';
+export type Product = 'OG Kush' | 'Sour Diesel' | 'Green Crack' | 'Grandaddy Purple' | 'Meth' | 'Cocaine';
 export type RankCode = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | '13';
 export interface EffectData {
     name: string;
+    description: string;
+    tier: number;
     price: number;
     color: string;
+    addiction: number;
 }
 export interface SubstanceData {
     abbreviation: string;
@@ -29,8 +32,9 @@ export interface MixResult {
     sellPrice: number;
     profit: number;
     profitMargin: number;
+    addiction: number;
 }
 export interface MixState {
-    product: ProductType;
-    substances: SubstanceCode[];
+    product: Product;
+    substances: Substance[];
 }

package/dist/utils/encoding.d.ts

@@ -1,11 +1,14 @@
 import type { MixState } from '../types';
 /**
  * Encode a mix state into a URL-safe string
+ * @param state - The mix state to encode
+ * @returns The URL-safe string
  * @throws Error if the product type or any substance code is invalid
  */
 export declare function encodeMixState(state: MixState): string;
 /**
  * Decode a mix state from a URL-safe string
+ * @param hash - The URL-safe string to decode
  * @returns The decoded MixState or null if invalid
  */
 export declare function decodeMixState(hash: string): MixState | null;

package/dist/utils/encoding.js

@@ -6,6 +6,8 @@ const products_1 = require("../data/products");
 const substances_1 = require("../data/substances");
 /**
  * Encode a mix state into a URL-safe string
+ * @param state - The mix state to encode
+ * @returns The URL-safe string
  * @throws Error if the product type or any substance code is invalid
  */
 function encodeMixState(state) {
@@ -29,6 +31,7 @@ function encodeMixState(state) {
 }
 /**
  * Decode a mix state from a URL-safe string
+ * @param hash - The URL-safe string to decode
  * @returns The decoded MixState or null if invalid
  */
 function decodeMixState(hash) {
@@ -45,7 +48,7 @@ function decodeMixState(hash) {
         if (!product || !products_1.products[product]) {
             return null;
         }
-        const substanceCodes = [];
+        const subs = [];
         if (substancesStr) {
             for (let i = 0; i < substancesStr.length; i++) {
                 const abbr = substancesStr[i];
@@ -53,12 +56,12 @@ function decodeMixState(hash) {
                 if (!fullName || !substances_1.substances[fullName]) {
                     return null;
                 }
-                substanceCodes.push(fullName);
+                subs.push(fullName);
             }
         }
         return {
             product: product,
-            substances: substanceCodes,
+            substances: subs,
         };
     }
     catch (error) {
@@ -67,6 +70,8 @@ function decodeMixState(hash) {
 }
 /**
  * Convert a string to a URL-safe base64 string
+ * @param str - The string to convert
+ * @returns The URL-safe base64 string
  */
 function toBase64Url(str) {
     return Buffer.from(str, 'utf-8')
@@ -77,6 +82,8 @@ function toBase64Url(str) {
 }
 /**
  * Convert a URL-safe base64 string back to a regular string
+ * @param str - The URL-safe base64 string to convert
+ * @returns The regular string
  */
 function fromBase64Url(str) {
     if (typeof str !== 'string') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schedule1-tools/mixer",
-  "version": "0.0.2",
+  "version": "0.2.2",
   "description": "A package for calculating substance mixes in Schedule 1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",