safe-math-ops 0.0.5 → 0.0.7

package/README.md

@@ -3,16 +3,14 @@
 The goal of this package was to prevent weird decimals from appearing.
 e.g. 9.99 - 8 = 1.9900000000000002 instead of 1.99
 
-To install dependencies:
+Example:
 
-```bash
-bun install
-```
+```ts
+import safeMath from "safe-math-ops";
 
-To run:
+// Expected output: 1.99
+console.log(safeMath.substract([9.99, 8]));
 
-```bash
-bun run index.ts
+// Expected output: 1.9900000000000002
+console.log(9.99 - 8);
 ```
-
-This project was created using `bun init` in bun v1.3.6. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/index.d.ts

@@ -1,14 +1,19 @@
 import add from "./libs/add";
-import calcHighestDecimalPoint from "./libs/calcHighestDecimalPoint";
+import calcHighestDecimalPoint, { calcDecimals } from "./libs/calcHighestDecimalPoint";
 import divide from "./libs/divide";
+import getPow from "./libs/getPow";
 import multiply from "./libs/multiply";
+import replaceByInt from "./libs/replaceByInt";
 import substract from "./libs/substract";
-export { add, substract, multiply, divide, calcHighestDecimalPoint };
+export { add, substract, multiply, divide, calcHighestDecimalPoint, calcDecimals, getPow, replaceByInt, };
 declare const _default: {
     add: typeof add;
     substract: typeof substract;
     multiply: typeof multiply;
     divide: typeof divide;
     calcHighestDecimalPoint: typeof calcHighestDecimalPoint;
+    calcDecimals: typeof calcDecimals;
+    getPow: typeof getPow;
+    replaceByInt: typeof replaceByInt;
 };
 export default _default;

package/dist/index.js

@@ -1 +1,89 @@
-var s={};setInterval(()=>{s={}},15000);var i=s;function c(l,o){let t=0;for(let e of l){if(o==="add")t+=e;if(o==="substract")t-=e;if(o==="divide")t/=e;if(o==="multiply")t*=e}t=t*l.length+"";let r=i[t];if(!r)i[t]=l.filter((e)=>typeof e==="number").map((e)=>(e.toString().split(".")?.[1]||"").length).sort((e,a)=>a-e)?.[0]||0,r=i[t];return{result:r,key:t}}function m(...l){let o=c(l,"add"),t="a"+o.key,r=i[t];if(!r)i[t]=parseFloat(l.filter((e)=>typeof e==="number").reduce((e,a)=>e+a).toFixed(o.result)),r=i[t];return r}function f(...l){let o=c(l,"divide"),t="d"+o.key,r=i[t];if(!r)i[t]=parseFloat(l.filter((e)=>typeof e==="number").reduce((e,a)=>e/a).toFixed(o.result)),r=i[t];return r}function n(...l){let o=c(l,"multiply"),t="m"+o.key,r=i[t];if(!r)i[t]=parseFloat(l.filter((e)=>typeof e==="number").reduce((e,a)=>e*a).toFixed(o.result)),r=i[t];return r}function u(...l){let o=c(l,"substract"),t="s"+o.key,r=i[t];if(!r)i[t]=parseFloat(l.filter((e)=>typeof e==="number").reduce((e,a)=>e-a).toFixed(o.result)),r=i[t];return r}var B={add:m,substract:u,multiply:n,divide:f,calcHighestDecimalPoint:c};export{u as substract,n as multiply,f as divide,B as default,c as calcHighestDecimalPoint,m as add};
+// src/libs/calcHighestDecimalPoint.ts
+function calcDecimals(number) {
+  const int = Math.trunc(number);
+  const len = (int + "").length + 1;
+  return number % 1 !== 0 ? (number + "").slice(len).length : 0;
+}
+function calcHighestDecimalPoint(numbers) {
+  let highest = 0;
+  for (let i = 0;i < numbers.length; i++) {
+    if ((numbers?.[i] || 0) % 1 === 0)
+      continue;
+    let v = calcDecimals(numbers?.[i] || 0);
+    if (v > highest)
+      highest = v;
+  }
+  return highest;
+}
+
+// src/libs/getPow.ts
+function getPow(amt) {
+  return amt === 0 ? 1 : 10 ** amt;
+}
+
+// src/libs/add.ts
+function add(numbers) {
+  const highDecimalPoint = calcHighestDecimalPoint(numbers);
+  const multiplier = getPow(highDecimalPoint);
+  return numbers.reduce((a, b) => {
+    return a * multiplier + b * multiplier;
+  }) / multiplier;
+}
+
+// src/libs/divide.ts
+function divide(numbers) {
+  const highDecimalPoint = calcHighestDecimalPoint(numbers);
+  const multiplier = getPow(highDecimalPoint);
+  return numbers.reduce((a, b) => {
+    return a * multiplier / (b * multiplier);
+  }) / multiplier;
+}
+
+// src/libs/multiply.ts
+function multiply(numbers) {
+  const highDecimalPoint = calcHighestDecimalPoint(numbers);
+  const multiplier = getPow(highDecimalPoint);
+  return numbers.reduce((a, b) => {
+    return a * multiplier * (b * multiplier);
+  }) / multiplier;
+}
+
+// src/libs/replaceByInt.ts
+function replaceByInt(numbers, multiplier) {
+  for (let i = 0;i < numbers.length; i++) {
+    numbers[i] *= multiplier;
+  }
+  return numbers;
+}
+
+// src/libs/substract.ts
+function substract(numbers) {
+  const highDecimalPoint = calcHighestDecimalPoint(numbers);
+  const multiplier = getPow(highDecimalPoint);
+  return numbers.reduce((a, b) => {
+    return a * multiplier - b * multiplier;
+  }) / multiplier;
+}
+
+// src/index.ts
+var src_default = {
+  add,
+  substract,
+  multiply,
+  divide,
+  calcHighestDecimalPoint,
+  calcDecimals,
+  getPow,
+  replaceByInt
+};
+export {
+  substract,
+  replaceByInt,
+  multiply,
+  getPow,
+  divide,
+  src_default as default,
+  calcHighestDecimalPoint,
+  calcDecimals,
+  add
+};

package/dist/libs/add.d.ts

@@ -0,0 +1 @@
+export default function add(numbers: number[]): number;

package/dist/libs/cache.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    [key: string]: any;
+};
+export default _default;

package/dist/libs/calcHighestDecimalPoint.d.ts

@@ -0,0 +1,2 @@
+export declare function calcDecimals(number: number): number;
+export default function calcHighestDecimalPoint(numbers: number[]): number;

package/dist/libs/divide.d.ts

@@ -0,0 +1 @@
+export default function divide(numbers: number[]): number;

package/dist/libs/getMultiplier.d.ts

@@ -0,0 +1 @@
+export default function getMultiplier(amt: number): number;

package/dist/libs/getPow.d.ts

@@ -0,0 +1 @@
+export default function getPow(amt: number): number;

package/dist/libs/multiply.d.ts

@@ -0,0 +1 @@
+export default function multiply(numbers: number[]): number;

package/dist/libs/replaceByInt.d.ts

@@ -0,0 +1 @@
+export default function replaceByInt(numbers: number[], multiplier: number): number[];

package/dist/libs/substract.d.ts

@@ -0,0 +1 @@
+export default function substract(numbers: number[]): number;

package/package.json

@@ -2,7 +2,7 @@
     "name": "safe-math-ops",
     "module": "src/index.ts",
     "type": "module",
-    "version": "0.0.5",
+    "version": "0.0.7",
     "devDependencies": {
         "@types/bun": "latest",
         "rimraf": "^6.1.3"
@@ -17,7 +17,7 @@
     ],
     "author": "ctev",
     "scripts": {
-        "build": "bun build --minify --target=node ./src/index.ts --outfile=dist/index.js && bun run build:declaration",
+        "build": "bun build --target=node ./src/index.ts --outfile=dist/index.js && bun run build:declaration",
         "build:declaration": "tsc --emitDeclarationOnly --project tsconfig.types.json",
         "postbuild": "rimraf tsconfig.types.tsbuildinfo"
     },
@@ -26,6 +26,7 @@
     "description": "The goal of this package was to prevent weird decimals from appearing when doing operations (e.g. 9.99 - 8 = 1.9900000000000002 instead of 1.99)",
     "files": [
         "dist/*.js",
-        "dist/*.d.ts"
+        "dist/*.d.ts",
+        "dist/**/*.d.ts"
     ]
 }