@signpostmarv/intermediary-number 0.5.1 → 0.6.0

package/index.js

@@ -2,4 +2,3 @@ export * from './lib/IntermediaryNumber';
 export * from './lib/IntermediaryNumberTypes';
 export * from './lib/Numbers';
 export * from './lib/NumberStrings';
-//# sourceMappingURL=index.js.map

package/lib/Docs.json.js

@@ -4,4 +4,3 @@ export class NotAnAmountString extends Error {
 export function is_string(maybe) {
     return 'string' === typeof maybe;
 }
-//# sourceMappingURL=Docs.json.js.map

package/lib/IntermediaryNumber.d.ts

@@ -21,7 +21,7 @@ export type CanConvertTypeJson = {
 };
 export type CanDoMathWithDispose_operator_types = 'divide' | 'minus' | 'modulo' | 'plus' | 'times';
 export type operand_types = IntermediaryNumber | IntermediaryCalculation | TokenScan;
-type TokenSpan_types = 'ignore' | 'nesting_open' | 'nesting_close' | 'numeric' | 'operation';
+type TokenSpan_types = 'ignore' | 'nesting_open' | 'nesting_close' | 'numeric' | 'operation' | 'Infinity';
 type TokenSpan_types_part_baked = Exclude<TokenSpan_types, 'ignore'>;
 type TokenScan_internals = {
     parsed: IntermediaryNumber | IntermediaryCalculation | undefined;
@@ -111,6 +111,15 @@ export declare class IntermediaryNumber implements CanDoMathWithDispose {
     static fromJson(json: CanConvertTypeJson): CanDoMath_result_types;
     static reuse_or_create(input: operand_types | input_types): operand_types;
 }
+export declare class IntermediaryNumberInfinity extends IntermediaryNumber {
+    static readonly One: IntermediaryNumberInfinity;
+    static readonly Zero: IntermediaryNumberInfinity;
+    isOne(): boolean;
+    isZero(): boolean;
+    toFraction(): Fraction;
+    toString(): string;
+    toStringCalculation(): string;
+}
 export declare class NotValid extends Error {
     readonly reason: unknown;
     readonly value: string;
@@ -121,6 +130,7 @@ export declare class IntermediaryCalculation implements CanResolveMathWithDispos
     readonly operation: operation_types;
     readonly right_operand: operand_types;
     constructor(left: operand_types, operation: operation_types, right: operand_types);
+    get has_infinity(): boolean;
     get left_type(): operand_type_property_types;
     get resolve_type(): string;
     get right_type(): operand_type_property_types;
@@ -169,6 +179,7 @@ export declare class TokenScanParseError extends Error {
     constructor(message: string, scan: TokenScan_parsing_value, state: TokenScan_tokenizer, current?: TokenSpan<TokenSpan_types>);
 }
 export declare class TokenScan implements CanResolveMathWithDispose {
+    #private;
     private readonly internal;
     readonly value: string | [TokenScan, operation_types, math_types];
     private constructor();

package/lib/IntermediaryNumber.js

@@ -115,6 +115,9 @@ function is_nesting_close(maybe) {
 function is_numeric(maybe) {
     return 'numeric' === maybe.type;
 }
+function is_infinity(maybe) {
+    return 'Infinity' === maybe.type;
+}
 export function is_operation_value(maybe) {
     if (!(maybe.length === 1
         && '+-/x*%'.includes(maybe))) {
@@ -317,6 +320,9 @@ export class IntermediaryNumber {
             }
             return new this(new Fraction(input));
         }
+        else if ('Infinity' === input) {
+            return new IntermediaryNumberInfinity(new BigNumber('Infinity'));
+        }
         throw new Error('Unsupported argument specified!');
     }
     static create_if_valid(input) {
@@ -358,6 +364,27 @@ export class IntermediaryNumber {
     }
 }
 //#endregion
+//#region IntermediaryNumberInfinity
+export class IntermediaryNumberInfinity extends IntermediaryNumber {
+    static One = new this(new BigNumber('Infinity'));
+    static Zero = new this(new BigNumber('Infinity'));
+    isOne() {
+        return false;
+    }
+    isZero() {
+        return false;
+    }
+    toFraction() {
+        throw new Error('Cannot convert infinity to Fraction');
+    }
+    toString() {
+        return 'Infinity';
+    }
+    toStringCalculation() {
+        return 'Infinity';
+    }
+}
+//#endregion
 //#region IntermediaryCalculation
 export class NotValid extends Error {
     reason;
@@ -392,6 +419,10 @@ export class IntermediaryCalculation {
         this.operation = operation;
         this.right_operand = right;
     }
+    get has_infinity() {
+        return (this.left_operand instanceof IntermediaryNumberInfinity
+            || this.right_operand instanceof IntermediaryNumberInfinity);
+    }
     get left_type() {
         if (this.left_operand instanceof IntermediaryCalculation) {
             return 'IntermediaryCalculation';
@@ -457,6 +488,10 @@ export class IntermediaryCalculation {
         return do_math(this, '+', value);
     }
     resolve() {
+        const reduced = IntermediaryCalculation.maybe_short_circuit(this.left_operand, this.operation, this.right_operand);
+        if (reduced instanceof IntermediaryNumber) {
+            return reduced;
+        }
         const left_operand = this.operand_to_IntermediaryNumber(this.left_operand);
         const right_operand = this.operand_to_IntermediaryNumber(this.right_operand);
         const left = left_operand.toBigNumberOrFraction();
@@ -506,8 +541,14 @@ export class IntermediaryCalculation {
         return value;
     }
     toJSON() {
-        const left = this.operand_to_IntermediaryNumber(this.left_operand);
-        const right = this.operand_to_IntermediaryNumber(this.right_operand);
+        const left = (this.left_operand instanceof IntermediaryCalculation
+            && this.left_operand.has_infinity)
+            ? this.left_operand
+            : this.operand_to_IntermediaryNumber(this.left_operand);
+        const right = (this.right_operand instanceof IntermediaryCalculation
+            && this.right_operand.has_infinity)
+            ? this.right_operand
+            : this.operand_to_IntermediaryNumber(this.right_operand);
         const maybe = IntermediaryCalculation.maybe_short_circuit(left, this.operation, right);
         if (maybe) {
             return maybe.toJSON();
@@ -571,6 +612,55 @@ export class IntermediaryCalculation {
     }
     static maybe_short_circuit(left, operation, right) {
         let value = undefined;
+        if (left instanceof IntermediaryNumberInfinity
+            && right instanceof IntermediaryNumberInfinity) {
+            if ('+' === operation
+                || '*' === operation) {
+                // infinity plus or multiplied by infintiy is infinity
+                return left;
+            }
+            else if ('-' === operation) {
+                return IntermediaryNumber.Zero;
+            }
+            else if ('/' === operation) {
+                return IntermediaryNumber.One;
+            }
+        }
+        if (left instanceof IntermediaryCalculation
+            && left.has_infinity
+            && (('+' === left.operation
+                && '-' === operation)
+                || ('-' === left.operation
+                    && '+' === operation))
+            && (right instanceof IntermediaryNumberInfinity)
+            && (!(left.left_operand instanceof IntermediaryNumberInfinity)
+                || !(left.right_operand instanceof IntermediaryNumberInfinity))) {
+            return (left.left_operand instanceof IntermediaryNumberInfinity
+                ? left.right_operand
+                : left.left_operand);
+        }
+        else if (right instanceof IntermediaryCalculation
+            && right.has_infinity
+            && (('+' === right.operation
+                && '-' === operation)
+                || ('-' === right.operation
+                    && '+' === operation))
+            && (left instanceof IntermediaryNumberInfinity)
+            && (!(right.left_operand instanceof IntermediaryNumberInfinity)
+                || !(right.right_operand instanceof IntermediaryNumberInfinity))) {
+            return (right.left_operand instanceof IntermediaryNumberInfinity
+                ? right.right_operand
+                : right.left_operand);
+        }
+        else if ('/' === operation
+            && !right.isOne()
+            && left instanceof IntermediaryCalculation
+            && left.has_infinity
+            && !(left.left_operand instanceof IntermediaryNumberInfinity)
+            && '*x'.includes(left.operation)
+            && right instanceof IntermediaryNumberInfinity) {
+            return left.left_operand;
+        }
         if ('+' === operation) {
             if (left.isZero()) {
                 value = right;
@@ -633,10 +723,7 @@ export class TokenScan {
         this.value = value;
     }
     get parsed() {
-        if (undefined === this.internal.parsed) {
-            this.internal.parsed = TokenScan.parse_scan(this);
-        }
-        return this.internal.parsed;
+        return this.#parse();
     }
     get resolve_type() {
         return this.parsed.resolve_type;
@@ -653,15 +740,21 @@ export class TokenScan {
     get valid() {
         if (undefined === this.internal.valid) {
             try {
-                this.parsed;
+                this.#parse();
                 this.internal.valid = true;
             }
-            catch (err) {
+            catch {
                 this.internal.valid = false;
             }
         }
         return this.internal.valid;
     }
+    #parse() {
+        if (undefined === this.internal.parsed) {
+            this.internal.parsed = TokenScan.parse_scan(this);
+        }
+        return this.internal.parsed;
+    }
     abs() {
         return this.parsed.abs();
     }
@@ -808,6 +901,9 @@ export class TokenScan {
         for (const entry of value.matchAll(/(\))/g)) {
             tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'nesting_close'));
         }
+        for (const entry of value.matchAll(/(\bInfinity\b)/g)) {
+            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'Infinity'));
+        }
         tokens = tokens.sort((a, b) => {
             return a.from - b.from;
         });
@@ -971,7 +1067,7 @@ export class TokenScan {
                 }
             }
         }
-        else if (is_numeric(is)) {
+        else if (is_numeric(is) || is_infinity(is)) {
             if ('left' === was.operand_mode) {
                 was.left_operand = IntermediaryNumber.create(value.substring(is.from, is.to));
                 was.operand_mode = 'right';
@@ -1012,4 +1108,3 @@ export class TokenScan {
     }
 }
 //#endregion
-//# sourceMappingURL=IntermediaryNumber.js.map

package/lib/IntermediaryNumberTypes.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=IntermediaryNumberTypes.js.map

package/lib/NumberStrings.js

@@ -51,4 +51,3 @@ export class NumberStrings {
         }
     }
 }
-//# sourceMappingURL=NumberStrings.js.map

package/lib/Numbers.js

@@ -47,4 +47,3 @@ export class Numbers {
         return result;
     }
 }
-//# sourceMappingURL=Numbers.js.map

package/package.json

@@ -11,21 +11,21 @@
 	"exports": "./index.js",
 	"types": "./index.d.ts",
 	"devDependencies": {
-		"@signpostmarv/eslint-config": "^0.1.0",
-		"@types/eslint": "^8.56.10",
+		"@satisfactory-dev/custom-assert": "^0.2.3",
+		"@signpostmarv/eslint-config": "^0.2.0",
+		"@types/eslint": "^9.6.0",
 		"@types/node": "^20.14.2",
 		"c8": "^10.1.2",
-		"eslint": "^8.57.0",
+		"eslint": "^9.9.1",
 		"glob": "^10.4.1",
 		"prettier": "^3.3.2",
 		"ts-node": "^10.9.2",
 		"typescript": "~5.5.2",
-		"typescript-eslint": "^7.13.0"
+		"typescript-eslint": "^8.2.0"
 	},
 	"dependencies": {
-		"@satisfactory-dev/custom-assert": "^0.2.2",
 		"bignumber.js": "^9.1.2",
 		"fraction.js": "^4.3.7"
 	},
-	"version": "0.5.1"
+	"version": "0.6.0"
 }

package/eslint.config.mjs

@@ -1,20 +0,0 @@
-import config from '@signpostmarv/eslint-config';
-import parser from '@typescript-eslint/parser';
-
-export default [
-	{
-		languageOptions: {
-			parser,
-			parserOptions: {
-				project: ['./tsconfig.eslint.json'],
-			},
-		},
-	},
-	...config,
-	{
-		ignores: [
-			'**/*.js',
-			'**/*.d.ts',
-		]
-	}
-];