@schedule1-tools/mixer 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Schedule1 Tools
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# Schedule1 Mixer
+
+A package for calculating substance mixes in the game Schedule 1.
+
+## Installation
+
+```bash
+npm install @schedule1-tools/mixer
+```
+
+## Usage
+
+```typescript
+import { mixSubstances, encodeMixState, decodeMixState } from '@schedule1-tools/mixer';
+
+// Calculate a mix
+const result = mixSubstances('OG Kush', ['A', 'B', 'C']);
+console.log(result);
+/*
+{
+  effects: ['En', 'Se', 'To'],
+  cost: 12,
+  sellPrice: 42,
+  profit: -5,
+  profitMargin: -0.119
+}
+*/
+
+// Encode a mix state for sharing
+const encoded = encodeMixState({
+  product: 'OG Kush',
+  substances: ['A', 'B', 'C'],
+});
+console.log(encoded); // "T0cgS3VzaDpBQkM"
+
+// Decode a mix state
+const decoded = decodeMixState('T0cgS3VzaDpBQkM');
+console.log(decoded);
+/*
+{
+  product: 'OG Kush',
+  substances: ['A', 'B', 'C']
+}
+*/
+```
+
+## Exports
+
+The package also exports the following data objects:
+
+- `effects`: Information about all effects
+- `products`: Information about all products
+- `substances`: Information about all substances
+- `effectRulesBySubstance`: Rules for how substances transform effects

package/dist/core/effectSet.d.ts

@@ -0,0 +1,41 @@
+import { EffectCode } from '../types';
+/**
+ * A class for efficiently managing a set of effects using a bitset
+ */
+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;
+    constructor(initialEffects?: EffectCode[]);
+    /**
+     * Add an effect to the set
+     * @returns true if the effect was added, false if it was already present
+     */
+    add(effect: EffectCode): boolean;
+    /**
+     * Remove an effect from the set
+     * @returns true if the effect was removed, false if it wasn't present
+     */
+    remove(effect: EffectCode): boolean;
+    /**
+     * Check if an effect is in the set
+     */
+    has(effect: EffectCode): boolean;
+    /**
+     * Convert the set to an array of effect codes
+     */
+    toArray(): EffectCode[];
+    /**
+     * Get the number of effects in the set
+     */
+    size(): number;
+    /**
+     * Create a copy of this effect set
+     */
+    clone(): EffectSet;
+}

package/dist/core/effectSet.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectSet = void 0;
+/**
+ * A class for efficiently managing a set of effects using a bitset
+ */
+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);
+        }
+    }
+    /**
+     * Add an effect to the set
+     * @returns true if the effect was added, false if it was already present
+     */
+    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;
+        return !alreadyExists;
+    }
+    /**
+     * Remove an effect from the set
+     * @returns true if the effect was removed, false if it wasn't present
+     */
+    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;
+        return existed;
+    }
+    /**
+     * Check if an effect is in the set
+     */
+    has(effect) {
+        const index = EffectSet.effectToIndex.get(effect);
+        if (index === undefined)
+            return false;
+        return (this.bits & (1 << index)) !== 0;
+    }
+    /**
+     * Convert the set to an array of effect codes
+     */
+    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;
+    }
+    /**
+     * Get the number of effects in the set
+     */
+    size() {
+        // Count the number of set bits using Brian Kernighan's algorithm
+        let count = 0;
+        let n = this.bits;
+        while (n) {
+            n &= n - 1;
+            count++;
+        }
+        return count;
+    }
+    /**
+     * Create a copy of this effect set
+     */
+    clone() {
+        const clone = new EffectSet();
+        clone.bits = this.bits;
+        return clone;
+    }
+}
+exports.EffectSet = EffectSet;
+EffectSet.effectToIndex = new Map();
+EffectSet.indexToEffect = new Map();
+EffectSet.initialized = false;

package/dist/core/mixer.d.ts

@@ -0,0 +1,5 @@
+import { MixResult, ProductType, SubstanceCode } from '../types';
+/**
+ * Calculate the result of mixing substances with a product
+ */
+export declare function mixSubstances(product: ProductType, substanceCodes: SubstanceCode[]): MixResult;

package/dist/core/mixer.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mixSubstances = mixSubstances;
+const effects_1 = require("../data/effects");
+const products_1 = require("../data/products");
+const substances_1 = require("../data/substances");
+const rules_1 = require("../data/rules");
+const effectSet_1 = require("./effectSet");
+const MAX_EFFECTS = 8;
+/**
+ * Calculate the result of mixing substances with a product
+ */
+function mixSubstances(product, substanceCodes) {
+    if (!products_1.products[product]) {
+        throw new Error(`Unknown product: ${product}`);
+    }
+    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) {
+            for (const effect of substance.effect) {
+                if (!effectsSet.has(effect)) {
+                    effectsSet.add(effect);
+                    if (effectsSet.size() >= MAX_EFFECTS)
+                        break;
+                }
+            }
+        }
+    }
+    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 profitMargin = Math.round((profit / sellPrice) * 100) / 100;
+    return {
+        effects: finalEffects,
+        cost: totalCost,
+        sellPrice,
+        profit,
+        profitMargin,
+    };
+}
+/**
+ * Apply the rules for a substance to the current effect set
+ */
+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);
+            }
+        }
+    }
+}
+/**
+ * Check if a rule's preconditions are met
+ */
+function checkRulePreconditions(rule, initialEffects) {
+    // Check if all required effects are present
+    for (const effect of rule.ifPresent) {
+        if (!initialEffects.has(effect))
+            return false;
+    }
+    // Check if all forbidden effects are absent
+    for (const effect of rule.ifNotPresent) {
+        if (initialEffects.has(effect))
+            return false;
+    }
+    // Check if at least one replaceable effect is present
+    for (const oldEffect of Object.keys(rule.replace)) {
+        if (initialEffects.has(oldEffect))
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if a rule meets phase two conditions
+ */
+function meetsPhaseTwo(rule, initialEffects, currentEffects, removedEffects) {
+    // All required effects must have been initially present
+    for (const effect of rule.ifPresent) {
+        if (!initialEffects.has(effect))
+            return false;
+    }
+    // At least one forbidden effect must have been removed
+    let hasRemovedForbidden = false;
+    for (const effect of rule.ifNotPresent) {
+        if (removedEffects.has(effect)) {
+            hasRemovedForbidden = true;
+            break;
+        }
+    }
+    if (!hasRemovedForbidden)
+        return false;
+    // All forbidden effects must be absent from current set
+    for (const effect of rule.ifNotPresent) {
+        if (currentEffects.has(effect))
+            return false;
+    }
+    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
+ */
+function applyReplaceEffects(replace, initialEffects, effectsSet, processedEffects, removedEffects) {
+    for (const [oldEffect, newEffect] of Object.entries(replace)) {
+        if (initialEffects.has(oldEffect)) {
+            effectsSet.remove(oldEffect);
+            effectsSet.add(newEffect);
+            processedEffects.add(oldEffect);
+            removedEffects.add(oldEffect);
+        }
+    }
+}
+/**
+ * Apply transformations to effects
+ */
+function applyTransformations(replace, effectsSet, processedEffects) {
+    for (const [oldEffect, newEffect] of Object.entries(replace)) {
+        if (effectsSet.has(oldEffect)) {
+            effectsSet.remove(oldEffect);
+            effectsSet.add(newEffect);
+            processedEffects.add(oldEffect);
+        }
+    }
+}
+/**
+ * Calculate the total value multiplier from effects
+ */
+function calculateEffectValue(effectCodes) {
+    var _a;
+    let value = 0;
+    for (const code of effectCodes) {
+        value += ((_a = effects_1.effects[code]) === null || _a === void 0 ? void 0 : _a.price) || 0;
+    }
+    return value;
+}

package/dist/data/effects.d.ts

@@ -0,0 +1,2 @@
+import { EffectCode, EffectData } from '../types';
+export declare const effects: Record<EffectCode, EffectData>;

package/dist/data/effects.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.effects = void 0;
+exports.effects = {
+    Ca: {
+        name: 'Calming',
+        price: 0.1,
+        color: '#fdba74',
+    },
+    Re: {
+        name: 'Refreshing',
+        price: 0.14,
+        color: '#bef264',
+    },
+    En: {
+        name: 'Energizing',
+        price: 0.22,
+        color: '#a3e635',
+    },
+    Se: {
+        name: 'Sedating',
+        price: 0.26,
+        color: '#818cf8',
+    },
+    Be: {
+        name: 'Bright-Eyed',
+        price: 0.4,
+        color: '#67e8f9',
+    },
+    Cd: {
+        name: 'Calorie-Dense',
+        price: 0.28,
+        color: '#e879f9',
+    },
+    Eu: {
+        name: 'Euphoric',
+        price: 0.18,
+        color: '#fde68a',
+    },
+    To: {
+        name: 'Toxic',
+        price: 0,
+        color: '#a3e635',
+    },
+    At: {
+        name: 'Athletic',
+        price: 0.32,
+        color: '#7dd3fc',
+    },
+    Ba: {
+        name: 'Balding',
+        price: 0.3,
+        color: '#c79232',
+    },
+    Ag: {
+        name: 'Anti-Gravity',
+        price: 0.54,
+        color: '#3b82f6',
+    },
+    Mu: {
+        name: 'Munchies',
+        price: 0.12,
+        color: '#C96E57',
+    },
+    Sl: {
+        name: 'Slippery',
+        price: 0.34,
+        color: '#7dd3fc',
+    },
+    Gi: {
+        name: 'Gingeritis',
+        price: 0.2,
+        color: '#fb923c',
+    },
+    Sn: {
+        name: 'Sneaky',
+        price: 0.24,
+        color: '#a8a29e',
+    },
+    Tp: {
+        name: 'Thought-Provoking',
+        price: 0.44,
+        color: '#f9a8d4',
+    },
+    Sp: {
+        name: 'Spicy',
+        price: 0.38,
+        color: '#f87171',
+    },
+    Pa: {
+        name: 'Paranoia',
+        price: 0,
+        color: '#f87171',
+    },
+    Tt: {
+        name: 'Tropic Thunder',
+        price: 0.46,
+        color: '#fdba74',
+    },
+    Gl: {
+        name: 'Glowing',
+        price: 0.48,
+        color: '#85E459',
+    },
+    Cy: {
+        name: 'Cyclopean',
+        price: 0.56,
+        color: '#FEC174',
+    },
+    Fo: {
+        name: 'Foggy',
+        price: 0.36,
+        color: '#94a3b8',
+    },
+    Ex: {
+        name: 'Explosive',
+        price: 0,
+        color: '#ef4444',
+    },
+    La: {
+        name: 'Laxative',
+        price: 0,
+        color: '#a16207',
+    },
+    Lf: {
+        name: 'Long Faced',
+        price: 0.52,
+        color: '#fde047',
+    },
+    Je: {
+        name: 'Jennerising',
+        price: 0.42,
+        color: '#e879f9',
+    },
+    El: {
+        name: 'Electrifying',
+        price: 0.5,
+        color: '#22d3ee',
+    },
+    Di: {
+        name: 'Disorienting',
+        price: 0,
+        color: '#FE7551',
+    },
+    Sc: {
+        name: 'Schizophrenia',
+        price: 0,
+        color: '#645AFD',
+    },
+    Si: {
+        name: 'Seizure-Inducing',
+        price: 0,
+        color: '#FEE900',
+    },
+    Zo: {
+        name: 'Zombifying',
+        price: 0.58,
+        color: '#71AB5D',
+    },
+    Fc: {
+        name: 'Focused',
+        price: 0.16,
+        color: '#75F1FD',
+    },
+    Sm: {
+        name: 'Smelly',
+        price: 0,
+        color: '#84cc16',
+    },
+    Sh: {
+        name: 'Shrinking',
+        price: 0.6,
+        color: '#B6FEDA',
+    },
+};

package/dist/data/products.d.ts

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

package/dist/data/products.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.productAbbreviations = exports.products = void 0;
+exports.products = {
+    'OG Kush': {
+        price: 35,
+        effects: ['Ca'],
+        abbreviation: 'OH',
+    },
+    'Sour Diesel': {
+        price: 35,
+        effects: ['Re'],
+        abbreviation: 'SL',
+    },
+    'Green Crack': {
+        price: 35,
+        effects: ['En'],
+        abbreviation: 'GK',
+    },
+    'Grandaddy Purple': {
+        price: 35,
+        effects: ['Se'],
+        abbreviation: 'GE',
+    },
+    Cocaine: {
+        price: 150,
+        effects: [],
+        abbreviation: 'CE',
+    },
+    Meth: {
+        price: 70,
+        effects: [],
+        abbreviation: 'MH',
+    },
+};
+exports.productAbbreviations = Object.entries(exports.products).reduce((acc, [product, data]) => {
+    acc[data.abbreviation] = product;
+    return acc;
+}, {});

package/dist/data/rules.d.ts

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

package/dist/data/rules.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.effectRulesBySubstance = void 0;
+exports.effectRulesBySubstance = {
+    A: [
+        { ifPresent: ['Eu'], ifNotPresent: ['La'], replace: { Eu: 'La' } },
+        { ifPresent: ['Fo'], ifNotPresent: ['Cy'], replace: { Fo: 'Cy' } },
+        { ifPresent: ['Gi'], ifNotPresent: ['Tp'], replace: { Gi: 'Tp' } },
+        { ifPresent: ['Mu'], ifNotPresent: ['At'], replace: { Mu: 'At' } },
+        { ifPresent: ['Sl'], ifNotPresent: ['Mu'], replace: { Sl: 'Mu' } },
+        { ifPresent: ['Sn'], ifNotPresent: ['Pa'], replace: { Sn: 'Pa' } },
+        { ifPresent: ['To'], ifNotPresent: ['Eu'], replace: { To: 'Eu' } },
+    ],
+    B: [
+        { ifPresent: ['At'], ifNotPresent: ['Mu'], replace: { At: 'Mu' } },
+        { ifPresent: ['Ca'], ifNotPresent: ['Be'], replace: { Ca: 'Be' } },
+        { ifPresent: ['Cy'], ifNotPresent: ['Fo'], replace: { Cy: 'Fo' } },
+        { ifPresent: ['El'], ifNotPresent: ['Re'], replace: { El: 'Re' } },
+        { ifPresent: ['Eu'], ifNotPresent: ['To'], replace: { Eu: 'To' } },
+        { ifPresent: ['Fc'], ifNotPresent: ['Ca'], replace: { Fc: 'Ca' } },
+        { ifPresent: ['La'], ifNotPresent: ['Eu'], replace: { La: 'Eu' } },
+        { ifPresent: ['Mu'], ifNotPresent: ['Sl'], replace: { Mu: 'Sl' } },
+        { ifPresent: ['Sh'], ifNotPresent: ['Pa'], replace: { Sh: 'Pa' } },
+        { ifPresent: ['Tp'], ifNotPresent: ['Gi'], replace: { Tp: 'Gi' } },
+    ],
+    C: [
+        { ifPresent: ['Di'], ifNotPresent: ['Gl'], replace: { Di: 'Gl' } },
+        { ifPresent: ['El'], ifNotPresent: ['Di'], replace: { El: 'Di' } },
+        { ifPresent: ['En'], ifNotPresent: ['Eu'], replace: { En: 'Eu' } },
+        { ifPresent: ['Eu'], ifNotPresent: ['Sp'], replace: { Eu: 'Sp' } },
+        { ifPresent: ['Gi'], ifNotPresent: ['Sm'], replace: { Gi: 'Sm' } },
+        { ifPresent: ['Je'], ifNotPresent: ['Sn'], replace: { Je: 'Sn' } },
+        { ifPresent: ['La'], ifNotPresent: ['Fo'], replace: { La: 'Fo' } },
+        { ifPresent: ['Mu'], ifNotPresent: ['Se'], replace: { Mu: 'Se' } },
+        { ifPresent: ['Pa'], ifNotPresent: ['Ca'], replace: { Pa: 'Ca' } },
+        { ifPresent: ['Sh'], ifNotPresent: ['Fc'], replace: { Sh: 'Fc' } },
+        { ifPresent: ['Sn'], ifNotPresent: ['Tt'], replace: { Sn: 'Tt' } },
+    ],
+    D: [
+        { ifPresent: ['Ag'], ifNotPresent: ['Sl'], replace: { Ag: 'Sl' } },
+        { ifPresent: ['Ba'], ifNotPresent: ['Sn'], replace: { Ba: 'Sn' } },
+        { ifPresent: ['Cd'], ifNotPresent: ['Ex'], replace: { Cd: 'Ex' } },
+        { ifPresent: ['Fc'], ifNotPresent: ['Eu'], replace: { Fc: 'Eu' } },
+        { ifPresent: ['Je'], ifNotPresent: ['Gi'], replace: { Je: 'Gi' } },
+        { ifPresent: ['Mu'], ifNotPresent: ['Ca'], replace: { Mu: 'Ca' } },
+        { ifPresent: ['Sh'], ifNotPresent: ['En'], replace: { Sh: 'En' } },
+    ],
+    E: [
+        { ifPresent: ['Di'], ifNotPresent: ['El'], replace: { Di: 'El' } },
+        { ifPresent: ['Eu'], ifNotPresent: ['En'], replace: { Eu: 'En' } },
+        { ifPresent: ['Fc'], ifNotPresent: ['Sh'], replace: { Fc: 'Sh' } },
+        { ifPresent: ['Fo'], ifNotPresent: ['La'], replace: { Fo: 'La' } },
+        { ifPresent: ['Gl'], ifNotPresent: ['Di'], replace: { Gl: 'Di' } },
+        { ifPresent: ['Sc'], ifNotPresent: ['Ba'], replace: { Sc: 'Ba' } },
+        { ifPresent: ['Se'], ifNotPresent: ['Mu'], replace: { Se: 'Mu' } },
+        { ifPresent: ['Sp'], ifNotPresent: ['Eu'], replace: { Sp: 'Eu' } },
+        { ifPresent: ['Tt'], ifNotPresent: ['Sn'], replace: { Tt: 'Sn' } },
+    ],
+    F: [
+        { ifPresent: ['Ca'], ifNotPresent: ['Ag'], replace: { Ca: 'Ag' } },
+        { ifPresent: ['Cd'], ifNotPresent: ['Sn'], replace: { Cd: 'Sn' } },
+        { ifPresent: ['Ex'], ifNotPresent: ['Se'], replace: { Ex: 'Se' } },
+        { ifPresent: ['Fc'], ifNotPresent: ['Je'], replace: { Fc: 'Je' } },
+    ],
+    G: [
+        { ifPresent: ['En'], ifNotPresent: ['Mu'], replace: { En: 'Mu' } },
+        { ifPresent: ['Eu'], ifNotPresent: ['Se'], replace: { Eu: 'Se' } },
+        { ifPresent: ['Fo'], ifNotPresent: ['To'], replace: { Fo: 'To' } },
+        { ifPresent: ['Mu'], ifNotPresent: ['Sc'], replace: { Mu: 'Sc' } },
+        { ifPresent: ['Pa'], ifNotPresent: ['Ag'], replace: { Pa: 'Ag' } },
+    ],
+    H: [
+        { ifPresent: ['Ca'], ifNotPresent: ['Sn'], replace: { Ca: 'Sn' } },
+        { ifPresent: ['Cy'], ifNotPresent: ['En'], replace: { Cy: 'En' } },
+        { ifPresent: ['Di'], ifNotPresent: ['Fc'], replace: { Di: 'Fc' } },
+        { ifPresent: ['En'], ifNotPresent: ['Tp'], replace: { En: 'Tp' } },
+        { ifPresent: ['Fc'], ifNotPresent: ['Si'], replace: { Fc: 'Si' } },
+        { ifPresent: ['Lf'], ifNotPresent: ['Re'], replace: { Lf: 'Re' } },
+        { ifPresent: ['Pa'], ifNotPresent: ['Je'], replace: { Pa: 'Je' } },
+        { ifPresent: ['Sm'], ifNotPresent: ['Ag'], replace: { Sm: 'Ag' } },
+        { ifPresent: ['To'], ifNotPresent: ['Sm'], replace: { To: 'Sm' } },
+    ],
+    I: [
+        { ifPresent: ['Ag'], ifNotPresent: ['Tt'], replace: { Ag: 'Tt' } },
+        { ifPresent: ['At'], ifNotPresent: ['Eu'], replace: { At: 'Eu' } },
+        { ifPresent: ['La'], ifNotPresent: ['Lf'], replace: { La: 'Lf' } },
+        { ifPresent: ['Mu'], ifNotPresent: ['To'], replace: { Mu: 'To' } },
+        { ifPresent: ['Sh'], ifNotPresent: ['Re'], replace: { Sh: 'Re' } },
+        { ifPresent: ['Sn'], ifNotPresent: ['Be'], replace: { Sn: 'Be' } },
+        { ifPresent: ['Tp'], ifNotPresent: ['Fc'], replace: { Tp: 'Fc' } },
+    ],
+    J: [
+        { ifPresent: ['Ca'], ifNotPresent: ['Ba'], replace: { Ca: 'Ba' } },
+        { ifPresent: ['Cd'], ifNotPresent: ['Gi'], replace: { Cd: 'Gi' } },
+        { ifPresent: ['Eu'], ifNotPresent: ['Si'], replace: { Eu: 'Si' } },
+        { ifPresent: ['Fo'], ifNotPresent: ['Pa'], replace: { Fo: 'Pa' } },
+        { ifPresent: ['Re'], ifNotPresent: ['Tp'], replace: { Re: 'Tp' } },
+        { ifPresent: ['To'], ifNotPresent: ['Sn'], replace: { To: 'Sn' } },
+    ],
+    K: [
+        { ifPresent: ['Ca'], ifNotPresent: ['Sl'], replace: { Ca: 'Sl' } },
+        { ifPresent: ['El'], ifNotPresent: ['At'], replace: { El: 'At' } },
+        { ifPresent: ['En'], ifNotPresent: ['Pa'], replace: { En: 'Pa' } },
+        { ifPresent: ['Fc'], ifNotPresent: ['Gi'], replace: { Fc: 'Gi' } },
+        { ifPresent: ['Fo'], ifNotPresent: ['Ca'], replace: { Fo: 'Ca' } },
+        { ifPresent: ['Gl'], ifNotPresent: ['To'], replace: { Gl: 'To' } },
+        { ifPresent: ['Mu'], ifNotPresent: ['Ag'], replace: { Mu: 'Ag' } },
+        { ifPresent: ['Pa'], ifNotPresent: ['Ba'], replace: { Pa: 'Ba' } },
+        { ifPresent: ['Sp'], ifNotPresent: ['Be'], replace: { Sp: 'Be' } },
+        { ifPresent: ['To'], ifNotPresent: ['Tt'], replace: { To: 'Tt' } },
+    ],
+    L: [
+        { ifPresent: ['At'], ifNotPresent: ['Sn'], replace: { At: 'Sn' } },
+        { ifPresent: ['Di'], ifNotPresent: ['To'], replace: { Di: 'To' } },
+        { ifPresent: ['Eu'], ifNotPresent: ['Be'], replace: { Eu: 'Be' } },
+        { ifPresent: ['La'], ifNotPresent: ['Ca'], replace: { La: 'Ca' } },
+        { ifPresent: ['Sh'], ifNotPresent: ['Gi'], replace: { Sh: 'Gi' } },
+    ],
+    M: [
+        { ifPresent: ['Ag'], ifNotPresent: ['Ca'], replace: { Ag: 'Ca' } },
+        { ifPresent: ['Gi'], ifNotPresent: ['Re'], replace: { Gi: 'Re' } },
+        { ifPresent: ['Si'], ifNotPresent: ['En'], replace: { Si: 'En' } },
+        { ifPresent: ['Tp'], ifNotPresent: ['El'], replace: { Tp: 'El' } },
+    ],
+    N: [
+        { ifPresent: ['At'], ifNotPresent: ['La'], replace: { At: 'La' } },
+        { ifPresent: ['Ca'], ifNotPresent: ['Gl'], replace: { Ca: 'Gl' } },
+        { ifPresent: ['En'], ifNotPresent: ['Cy'], replace: { En: 'Cy' } },
+        { ifPresent: ['Fc'], ifNotPresent: ['Di'], replace: { Fc: 'Di' } },
+        { ifPresent: ['Je'], ifNotPresent: ['Pa'], replace: { Je: 'Pa' } },
+        { ifPresent: ['Si'], ifNotPresent: ['Fc'], replace: { Si: 'Fc' } },
+        { ifPresent: ['Sh'], ifNotPresent: ['El'], replace: { Sh: 'El' } },
+        { ifPresent: ['Sl'], ifNotPresent: ['To'], replace: { Sl: 'To' } },
+        { ifPresent: ['Sn'], ifNotPresent: ['Ca'], replace: { Sn: 'Ca' } },
+        { ifPresent: ['Tp'], ifNotPresent: ['En'], replace: { Tp: 'En' } },
+    ],
+    O: [
+        { ifPresent: ['Ex'], ifNotPresent: ['Eu'], replace: { Ex: 'Eu' } },
+        { ifPresent: ['Fo'], ifNotPresent: ['En'], replace: { Fo: 'En' } },
+        { ifPresent: ['Gl'], ifNotPresent: ['Re'], replace: { Gl: 'Re' } },
+        { ifPresent: ['Lf'], ifNotPresent: ['El'], replace: { Lf: 'El' } },
+        { ifPresent: ['Se'], ifNotPresent: ['Gi'], replace: { Se: 'Gi' } },
+    ],
+    P: [
+        { ifPresent: ['Cy'], ifNotPresent: ['Gl'], replace: { Cy: 'Gl' } },
+        { ifPresent: ['El'], ifNotPresent: ['Eu'], replace: { El: 'Eu' } },
+        { ifPresent: ['Eu'], ifNotPresent: ['Zo'], replace: { Eu: 'Zo' } },
+        { ifPresent: ['La'], ifNotPresent: ['Cd'], replace: { La: 'Cd' } },
+        { ifPresent: ['Mu'], ifNotPresent: ['Tt'], replace: { Mu: 'Tt' } },
+        { ifPresent: ['Sh'], ifNotPresent: ['Mu'], replace: { Sh: 'Mu' } },
+    ],
+};

package/dist/data/substances.d.ts

@@ -0,0 +1,2 @@
+import { SubstanceCode, SubstanceData } from '../types';
+export declare const substances: Record<SubstanceCode, SubstanceData>;

package/dist/data/substances.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.substances = void 0;
+exports.substances = {
+    A: {
+        name: 'Cuke',
+        rank: '1',
+        price: 2,
+        effect: ['En'],
+    },
+    B: {
+        name: 'Flu Medicine',
+        rank: '4',
+        price: 5,
+        effect: ['Se'],
+    },
+    C: {
+        name: 'Gasoline',
+        rank: '5',
+        price: 5,
+        effect: ['To'],
+    },
+    D: {
+        name: 'Donut',
+        rank: '1',
+        price: 3,
+        effect: ['Cd'],
+    },
+    E: {
+        name: 'Energy Drink',
+        rank: '6',
+        price: 6,
+        effect: ['At'],
+    },
+    F: {
+        name: 'Mouth Wash',
+        rank: '3',
+        price: 4,
+        effect: ['Ba'],
+    },
+    G: {
+        name: 'Motor Oil',
+        rank: '7',
+        price: 6,
+        effect: ['Sl'],
+    },
+    H: {
+        name: 'Banana',
+        rank: '1',
+        price: 2,
+        effect: ['Gi'],
+    },
+    I: {
+        name: 'Chili',
+        rank: '9',
+        price: 7,
+        effect: ['Sp'],
+    },
+    J: {
+        name: 'Iodine',
+        rank: '11',
+        price: 8,
+        effect: ['Je'],
+    },
+    K: {
+        name: 'Paracetamol',
+        rank: '1',
+        price: 3,
+        effect: ['Sn'],
+    },
+    L: {
+        name: 'Viagra',
+        rank: '2',
+        price: 4,
+        effect: ['Tt'],
+    },
+    M: {
+        name: 'Horse Semen',
+        rank: '13',
+        price: 9,
+        effect: ['Lf'],
+    },
+    N: {
+        name: 'Mega Bean',
+        rank: '8',
+        price: 7,
+        effect: ['Fo'],
+    },
+    O: {
+        name: 'Addy',
+        rank: '12',
+        price: 9,
+        effect: ['Tp'],
+    },
+    P: {
+        name: 'Battery',
+        rank: '10',
+        price: 8,
+        effect: ['Be'],
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { mixSubstances } 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';

package/dist/index.js

@@ -0,0 +1,19 @@
+"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;
+// Main exports
+var mixer_1 = require("./core/mixer");
+Object.defineProperty(exports, "mixSubstances", { enumerable: true, get: function () { return mixer_1.mixSubstances; } });
+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; } });
+// Data exports
+var effects_1 = require("./data/effects");
+Object.defineProperty(exports, "effects", { enumerable: true, get: function () { return effects_1.effects; } });
+var products_1 = require("./data/products");
+Object.defineProperty(exports, "products", { enumerable: true, get: function () { return products_1.products; } });
+Object.defineProperty(exports, "productAbbreviations", { enumerable: true, get: function () { return products_1.productAbbreviations; } });
+var substances_1 = require("./data/substances");
+Object.defineProperty(exports, "substances", { enumerable: true, get: function () { return substances_1.substances; } });
+var rules_1 = require("./data/rules");
+Object.defineProperty(exports, "effectRulesBySubstance", { enumerable: true, get: function () { return rules_1.effectRulesBySubstance; } });

package/dist/types.d.ts

@@ -0,0 +1,36 @@
+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 = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P';
+export type ProductType = '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;
+    price: number;
+    color: string;
+}
+export interface SubstanceData {
+    name: string;
+    rank: RankCode;
+    price: number;
+    effect: EffectCode[];
+}
+export interface ProductData {
+    price: number;
+    effects: EffectCode[];
+    abbreviation: string;
+}
+export interface EffectRule {
+    ifPresent: EffectCode[];
+    ifNotPresent: EffectCode[];
+    replace: Partial<Record<EffectCode, EffectCode>>;
+}
+export interface MixResult {
+    effects: EffectCode[];
+    cost: number;
+    sellPrice: number;
+    profit: number;
+    profitMargin: number;
+}
+export interface MixState {
+    product: ProductType;
+    substances: SubstanceCode[];
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/encoding.d.ts

@@ -0,0 +1,9 @@
+import { MixState } from '../types';
+/**
+ * Encode a mix state into a URL-safe string
+ */
+export declare function encodeMixState(state: MixState): string;
+/**
+ * Decode a mix state from a URL-safe string
+ */
+export declare function decodeMixState(hash: string): MixState | null;

package/dist/utils/encoding.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeMixState = encodeMixState;
+exports.decodeMixState = decodeMixState;
+const products_1 = require("../data/products");
+const substances_1 = require("../data/substances");
+/**
+ * Encode a mix state into a URL-safe string
+ */
+function encodeMixState(state) {
+    // Validate inputs
+    if (!products_1.products[state.product]) {
+        throw new Error('Invalid product type');
+    }
+    for (const substance of state.substances) {
+        if (!substances_1.substances[substance]) {
+            throw new Error(`Invalid substance code: ${substance}`);
+        }
+    }
+    const encoded = `${state.product}:${state.substances.join('')}`;
+    return toBase64Url(encoded);
+}
+/**
+ * Decode a mix state from a URL-safe string
+ */
+function decodeMixState(hash) {
+    try {
+        const decoded = fromBase64Url(hash);
+        const [product, substancesStr] = decoded.split(':');
+        if (!product || substancesStr === undefined || !products_1.products[product]) {
+            return null;
+        }
+        const substanceCodes = substancesStr.split('');
+        // Validate substances
+        for (const code of substanceCodes) {
+            if (!substances_1.substances[code]) {
+                return null;
+            }
+        }
+        return {
+            product: product,
+            substances: substanceCodes,
+        };
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/**
+ * Convert a string to a URL-safe base64 string
+ */
+function toBase64Url(str) {
+    return Buffer.from(str, 'binary')
+        .toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=/g, '');
+}
+/**
+ * Convert a URL-safe base64 string back to a regular string
+ */
+function fromBase64Url(str) {
+    const base64 = str.replace(/-/g, '+').replace(/_/g, '/');
+    const padding = 4 - (base64.length % 4);
+    const padded = padding < 4 ? base64 + '='.repeat(padding) : base64;
+    return Buffer.from(padded, 'base64').toString('binary');
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@schedule1-tools/mixer",
+  "version": "0.0.0",
+  "description": "A package for calculating substance mixes in Schedule 1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "schedule1"
+  ],
+  "author": "Schedule1 Tools",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.14.1",
+    "prettier": "^3.5.3",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.3.2",
+    "typescript": "^5.8.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/schedule1-tools/mixer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/schedule1-tools/mixer/issues"
+  },
+  "homepage": "https://github.com/schedule1-tools/mixer#readme",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "format": "prettier --write ."
+  }
+}