@schedule1-tools/mixer 0.0.0 → 0.0.2

package/README.md

@@ -10,36 +10,42 @@ npm install @schedule1-tools/mixer
 
 ## Usage
 
+### Calculate a mix
+
 ```typescript
-import { mixSubstances, encodeMixState, decodeMixState } from '@schedule1-tools/mixer';
+const result = mixSubstances('OG Kush', ['Cuke', 'Flu Medicine', 'Gasoline']);
 
-// Calculate a mix
-const result = mixSubstances('OG Kush', ['A', 'B', 'C']);
-console.log(result);
 /*
 {
-  effects: ['En', 'Se', 'To'],
+  effects: [ 'Be', 'Eu', 'Se', 'To' ],
   cost: 12,
-  sellPrice: 42,
-  profit: -5,
-  profitMargin: -0.119
+  sellPrice: 64,
+  profit: 17,
+  profitMargin: 0.27
 }
 */
+```
+
+### Encode a mix state for sharing
 
-// Encode a mix state for sharing
+```typescript
 const encoded = encodeMixState({
   product: 'OG Kush',
-  substances: ['A', 'B', 'C'],
+  substances: ['Cuke', 'Flu Medicine', 'Gasoline'],
 });
-console.log(encoded); // "T0cgS3VzaDpBQkM"
 
-// Decode a mix state
+// "T0cgS3VzaDpBQkM"
+```
+
+### Decode a mix state
+
+```typescript
 const decoded = decodeMixState('T0cgS3VzaDpBQkM');
-console.log(decoded);
+
 /*
 {
   product: 'OG Kush',
-  substances: ['A', 'B', 'C']
+  substances: [ 'Cuke', 'Flu Medicine', 'Gasoline' ]
 }
 */
 ```
@@ -52,3 +58,7 @@ The package also exports the following data objects:
 - `products`: Information about all products
 - `substances`: Information about all substances
 - `effectRulesBySubstance`: Rules for how substances transform effects
+
+## Notice
+
+This is a fan-made project and is not affiliated with, authorized, maintained, sponsored, or endorsed by the developers of Schedule I the game. All game-related content, including but not limited to names, trademarks, and copyrights, belong to their respective owners.

package/dist/core/effectSet.d.ts

@@ -1,7 +1,4 @@
-import { EffectCode } from '../types';
-/**
- * A class for efficiently managing a set of effects using a bitset
- */
+import type { EffectCode } from '../types';
 export declare class EffectSet {
     private static readonly effectToIndex;
     private static readonly indexToEffect;

package/dist/core/effectSet.js

@@ -1,9 +1,6 @@
 "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
@@ -113,7 +110,6 @@ class EffectSet {
      * 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) {

package/dist/core/mixer.d.ts

@@ -1,4 +1,4 @@
-import { MixResult, ProductType, SubstanceCode } from '../types';
+import type { MixResult, ProductType, SubstanceCode } from '../types';
 /**
  * Calculate the result of mixing substances with a product
  */

package/dist/core/mixer.js

@@ -3,8 +3,8 @@ 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 substances_1 = require("../data/substances");
 const effectSet_1 = require("./effectSet");
 const MAX_EFFECTS = 8;
 /**

package/dist/data/effects.d.ts

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

package/dist/data/products.d.ts

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

package/dist/data/rules.d.ts

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

package/dist/data/rules.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.effectRulesBySubstance = void 0;
 exports.effectRulesBySubstance = {
-    A: [
+    Cuke: [
         { ifPresent: ['Eu'], ifNotPresent: ['La'], replace: { Eu: 'La' } },
         { ifPresent: ['Fo'], ifNotPresent: ['Cy'], replace: { Fo: 'Cy' } },
         { ifPresent: ['Gi'], ifNotPresent: ['Tp'], replace: { Gi: 'Tp' } },
@@ -11,7 +11,7 @@ exports.effectRulesBySubstance = {
         { ifPresent: ['Sn'], ifNotPresent: ['Pa'], replace: { Sn: 'Pa' } },
         { ifPresent: ['To'], ifNotPresent: ['Eu'], replace: { To: 'Eu' } },
     ],
-    B: [
+    'Flu Medicine': [
         { ifPresent: ['At'], ifNotPresent: ['Mu'], replace: { At: 'Mu' } },
         { ifPresent: ['Ca'], ifNotPresent: ['Be'], replace: { Ca: 'Be' } },
         { ifPresent: ['Cy'], ifNotPresent: ['Fo'], replace: { Cy: 'Fo' } },
@@ -23,7 +23,7 @@ exports.effectRulesBySubstance = {
         { ifPresent: ['Sh'], ifNotPresent: ['Pa'], replace: { Sh: 'Pa' } },
         { ifPresent: ['Tp'], ifNotPresent: ['Gi'], replace: { Tp: 'Gi' } },
     ],
-    C: [
+    Gasoline: [
         { ifPresent: ['Di'], ifNotPresent: ['Gl'], replace: { Di: 'Gl' } },
         { ifPresent: ['El'], ifNotPresent: ['Di'], replace: { El: 'Di' } },
         { ifPresent: ['En'], ifNotPresent: ['Eu'], replace: { En: 'Eu' } },
@@ -36,7 +36,7 @@ exports.effectRulesBySubstance = {
         { ifPresent: ['Sh'], ifNotPresent: ['Fc'], replace: { Sh: 'Fc' } },
         { ifPresent: ['Sn'], ifNotPresent: ['Tt'], replace: { Sn: 'Tt' } },
     ],
-    D: [
+    Donut: [
         { ifPresent: ['Ag'], ifNotPresent: ['Sl'], replace: { Ag: 'Sl' } },
         { ifPresent: ['Ba'], ifNotPresent: ['Sn'], replace: { Ba: 'Sn' } },
         { ifPresent: ['Cd'], ifNotPresent: ['Ex'], replace: { Cd: 'Ex' } },
@@ -45,7 +45,7 @@ exports.effectRulesBySubstance = {
         { ifPresent: ['Mu'], ifNotPresent: ['Ca'], replace: { Mu: 'Ca' } },
         { ifPresent: ['Sh'], ifNotPresent: ['En'], replace: { Sh: 'En' } },
     ],
-    E: [
+    'Energy Drink': [
         { ifPresent: ['Di'], ifNotPresent: ['El'], replace: { Di: 'El' } },
         { ifPresent: ['Eu'], ifNotPresent: ['En'], replace: { Eu: 'En' } },
         { ifPresent: ['Fc'], ifNotPresent: ['Sh'], replace: { Fc: 'Sh' } },
@@ -56,20 +56,20 @@ exports.effectRulesBySubstance = {
         { ifPresent: ['Sp'], ifNotPresent: ['Eu'], replace: { Sp: 'Eu' } },
         { ifPresent: ['Tt'], ifNotPresent: ['Sn'], replace: { Tt: 'Sn' } },
     ],
-    F: [
+    'Mouth Wash': [
         { 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: [
+    'Motor Oil': [
         { 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: [
+    Banana: [
         { ifPresent: ['Ca'], ifNotPresent: ['Sn'], replace: { Ca: 'Sn' } },
         { ifPresent: ['Cy'], ifNotPresent: ['En'], replace: { Cy: 'En' } },
         { ifPresent: ['Di'], ifNotPresent: ['Fc'], replace: { Di: 'Fc' } },
@@ -80,7 +80,7 @@ exports.effectRulesBySubstance = {
         { ifPresent: ['Sm'], ifNotPresent: ['Ag'], replace: { Sm: 'Ag' } },
         { ifPresent: ['To'], ifNotPresent: ['Sm'], replace: { To: 'Sm' } },
     ],
-    I: [
+    Chili: [
         { ifPresent: ['Ag'], ifNotPresent: ['Tt'], replace: { Ag: 'Tt' } },
         { ifPresent: ['At'], ifNotPresent: ['Eu'], replace: { At: 'Eu' } },
         { ifPresent: ['La'], ifNotPresent: ['Lf'], replace: { La: 'Lf' } },
@@ -89,7 +89,7 @@ exports.effectRulesBySubstance = {
         { ifPresent: ['Sn'], ifNotPresent: ['Be'], replace: { Sn: 'Be' } },
         { ifPresent: ['Tp'], ifNotPresent: ['Fc'], replace: { Tp: 'Fc' } },
     ],
-    J: [
+    Iodine: [
         { ifPresent: ['Ca'], ifNotPresent: ['Ba'], replace: { Ca: 'Ba' } },
         { ifPresent: ['Cd'], ifNotPresent: ['Gi'], replace: { Cd: 'Gi' } },
         { ifPresent: ['Eu'], ifNotPresent: ['Si'], replace: { Eu: 'Si' } },
@@ -97,7 +97,7 @@ exports.effectRulesBySubstance = {
         { ifPresent: ['Re'], ifNotPresent: ['Tp'], replace: { Re: 'Tp' } },
         { ifPresent: ['To'], ifNotPresent: ['Sn'], replace: { To: 'Sn' } },
     ],
-    K: [
+    Paracetamol: [
         { ifPresent: ['Ca'], ifNotPresent: ['Sl'], replace: { Ca: 'Sl' } },
         { ifPresent: ['El'], ifNotPresent: ['At'], replace: { El: 'At' } },
         { ifPresent: ['En'], ifNotPresent: ['Pa'], replace: { En: 'Pa' } },
@@ -109,20 +109,20 @@ exports.effectRulesBySubstance = {
         { ifPresent: ['Sp'], ifNotPresent: ['Be'], replace: { Sp: 'Be' } },
         { ifPresent: ['To'], ifNotPresent: ['Tt'], replace: { To: 'Tt' } },
     ],
-    L: [
+    Viagra: [
         { 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: [
+    'Horse Semen': [
         { 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: [
+    'Mega Bean': [
         { ifPresent: ['At'], ifNotPresent: ['La'], replace: { At: 'La' } },
         { ifPresent: ['Ca'], ifNotPresent: ['Gl'], replace: { Ca: 'Gl' } },
         { ifPresent: ['En'], ifNotPresent: ['Cy'], replace: { En: 'Cy' } },
@@ -134,14 +134,14 @@ exports.effectRulesBySubstance = {
         { ifPresent: ['Sn'], ifNotPresent: ['Ca'], replace: { Sn: 'Ca' } },
         { ifPresent: ['Tp'], ifNotPresent: ['En'], replace: { Tp: 'En' } },
     ],
-    O: [
+    Addy: [
         { 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: [
+    Battery: [
         { ifPresent: ['Cy'], ifNotPresent: ['Gl'], replace: { Cy: 'Gl' } },
         { ifPresent: ['El'], ifNotPresent: ['Eu'], replace: { El: 'Eu' } },
         { ifPresent: ['Eu'], ifNotPresent: ['Zo'], replace: { Eu: 'Zo' } },

package/dist/data/substances.d.ts

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

package/dist/data/substances.js

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

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 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 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 RankCode = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | '13';
 export interface EffectData {
@@ -8,7 +8,7 @@ export interface EffectData {
     color: string;
 }
 export interface SubstanceData {
-    name: string;
+    abbreviation: string;
     rank: RankCode;
     price: number;
     effect: EffectCode[];

package/dist/utils/encoding.d.ts

@@ -1,9 +1,11 @@
-import { MixState } from '../types';
+import type { MixState } from '../types';
 /**
  * Encode a mix state into a 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
+ * @returns The decoded MixState or null if invalid
  */
 export declare function decodeMixState(hash: string): MixState | null;

package/dist/utils/encoding.js

@@ -6,35 +6,54 @@ const products_1 = require("../data/products");
 const substances_1 = require("../data/substances");
 /**
  * Encode a mix state into a URL-safe string
+ * @throws Error if the product type or any substance code is invalid
  */
 function encodeMixState(state) {
-    // Validate inputs
     if (!products_1.products[state.product]) {
-        throw new Error('Invalid product type');
+        throw new Error(`Invalid product type: ${state.product}`);
     }
     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('')}`;
+    const abbreviatedSubstances = state.substances.map((s) => {
+        const abbr = substances_1.substances[s].abbreviation;
+        if (!abbr) {
+            throw new Error(`Missing abbreviation for substance: ${s}`);
+        }
+        return abbr;
+    });
+    const encoded = `${state.product}:${abbreviatedSubstances.join('')}`;
     return toBase64Url(encoded);
 }
 /**
  * Decode a mix state from a URL-safe string
+ * @returns The decoded MixState or null if invalid
  */
 function decodeMixState(hash) {
+    if (!hash || typeof hash !== 'string') {
+        return null;
+    }
     try {
         const decoded = fromBase64Url(hash);
-        const [product, substancesStr] = decoded.split(':');
-        if (!product || substancesStr === undefined || !products_1.products[product]) {
+        const parts = decoded.split(':');
+        if (parts.length !== 2) {
             return null;
         }
-        const substanceCodes = substancesStr.split('');
-        // Validate substances
-        for (const code of substanceCodes) {
-            if (!substances_1.substances[code]) {
-                return null;
+        const [product, substancesStr] = parts;
+        if (!product || !products_1.products[product]) {
+            return null;
+        }
+        const substanceCodes = [];
+        if (substancesStr) {
+            for (let i = 0; i < substancesStr.length; i++) {
+                const abbr = substancesStr[i];
+                const fullName = substances_1.substanceAbbreviations[abbr];
+                if (!fullName || !substances_1.substances[fullName]) {
+                    return null;
+                }
+                substanceCodes.push(fullName);
             }
         }
         return {
@@ -42,7 +61,7 @@ function decodeMixState(hash) {
             substances: substanceCodes,
         };
     }
-    catch (_a) {
+    catch (error) {
         return null;
     }
 }
@@ -50,7 +69,7 @@ function decodeMixState(hash) {
  * Convert a string to a URL-safe base64 string
  */
 function toBase64Url(str) {
-    return Buffer.from(str, 'binary')
+    return Buffer.from(str, 'utf-8')
         .toString('base64')
         .replace(/\+/g, '-')
         .replace(/\//g, '_')
@@ -60,8 +79,11 @@ function toBase64Url(str) {
  * Convert a URL-safe base64 string back to a regular string
  */
 function fromBase64Url(str) {
+    if (typeof str !== 'string') {
+        throw new Error('Input must be a string');
+    }
     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');
+    const padding = base64.length % 4;
+    const padded = padding ? base64 + '='.repeat(4 - padding) : base64;
+    return Buffer.from(padded, 'base64').toString('utf-8');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schedule1-tools/mixer",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "description": "A package for calculating substance mixes in Schedule 1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,10 +13,11 @@
   "author": "Schedule1 Tools",
   "license": "MIT",
   "devDependencies": {
+    "@ianvs/prettier-plugin-sort-imports": "^4.4.1",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.14.1",
-    "prettier": "^3.5.3",
     "jest": "^29.7.0",
+    "prettier": "^3.5.3",
     "ts-jest": "^29.3.2",
     "typescript": "^5.8.3"
   },