@choksheak/ts-utils 0.2.3 → 0.2.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@choksheak/ts-utils",
   "license": "The Unlicense",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Random Typescript utilities with support for full tree-shaking",
   "private": false,
   "scripts": {

package/round.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Simplifies rounding of floating point numbers. Note that if your number ends
+ * with zeros, and you convert the number to string, you will lose the zeroes
+ * at the end. To show the exact number of decimal places, you'll need to use
+ * toFixed(). E.g. round(1.20, 2).toFixed(2).
+ */
+export declare function round(n: number, numDecimalPlaces?: number): number;
+/**
+ * Returns a string with the number in the exact number of decimal places
+ * specified, in case the number ends with zeroes.
+ */
+export declare function roundS(n: number, numDecimalPlaces?: number): string;

package/round.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/round.ts
+var round_exports = {};
+__export(round_exports, {
+  round: () => round,
+  roundS: () => roundS
+});
+module.exports = __toCommonJS(round_exports);
+function round(n, numDecimalPlaces = 0) {
+  const multipler = Math.pow(10, numDecimalPlaces);
+  return Math.round(n * multipler) / multipler;
+}
+function roundS(n, numDecimalPlaces = 0) {
+  return round(n, numDecimalPlaces).toFixed(numDecimalPlaces);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  round,
+  roundS
+});
+//# sourceMappingURL=round.js.map

package/round.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/round.ts"],"sourcesContent":["/**\n * Simplifies rounding of floating point numbers. Note that if your number ends\n * with zeros, and you convert the number to string, you will lose the zeroes\n * at the end. To show the exact number of decimal places, you'll need to use\n * toFixed(). E.g. round(1.20, 2).toFixed(2).\n */\nexport function round(n: number, numDecimalPlaces = 0): number {\n  const multipler = Math.pow(10, numDecimalPlaces);\n  return Math.round(n * multipler) / multipler;\n}\n\n/**\n * Returns a string with the number in the exact number of decimal places\n * specified, in case the number ends with zeroes.\n */\nexport function roundS(n: number, numDecimalPlaces = 0): string {\n  return round(n, numDecimalPlaces).toFixed(numDecimalPlaces);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMO,SAAS,MAAM,GAAW,mBAAmB,GAAW;AAC7D,QAAM,YAAY,KAAK,IAAI,IAAI,gBAAgB;AAC/C,SAAO,KAAK,MAAM,IAAI,SAAS,IAAI;AACrC;AAMO,SAAS,OAAO,GAAW,mBAAmB,GAAW;AAC9D,SAAO,MAAM,GAAG,gBAAgB,EAAE,QAAQ,gBAAgB;AAC5D;","names":[]}

package/safeParseFloat.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns 0 or the given defaultValue if the string is not a valid number.
+ */
+export declare function safeParseFloat<T>(s: string, defaultValue?: T | number): T | number;

package/safeParseFloat.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/safeParseFloat.ts
+var safeParseFloat_exports = {};
+__export(safeParseFloat_exports, {
+  safeParseFloat: () => safeParseFloat
+});
+module.exports = __toCommonJS(safeParseFloat_exports);
+function safeParseFloat(s, defaultValue = 0) {
+  const i = Number(s);
+  return isNaN(i) ? defaultValue : i;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  safeParseFloat
+});
+//# sourceMappingURL=safeParseFloat.js.map

package/safeParseFloat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/safeParseFloat.ts"],"sourcesContent":["/**\n * Returns 0 or the given defaultValue if the string is not a valid number.\n */\nexport function safeParseFloat<T>(\n  s: string,\n  defaultValue: T | number = 0,\n): T | number {\n  const i = Number(s);\n  return isNaN(i) ? defaultValue : i;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,SAAS,eACd,GACA,eAA2B,GACf;AACZ,QAAM,IAAI,OAAO,CAAC;AAClB,SAAO,MAAM,CAAC,IAAI,eAAe;AACnC;","names":[]}

package/safeParseInt.d.ts

@@ -1,7 +1,4 @@
 /**
- * Returns 0 if the string is not a valid number.
- *
- * @param logError Log a console error if the given string is not a valid
- *   number. Defaults to false (don't log anything).
+ * Returns 0 or the given defaultValue if the string is not a valid number.
  */
-export declare function safeParseInt(s: string, logError?: boolean): number;
+export declare function safeParseInt<T>(s: string, defaultValue?: T | number): T | number;

package/safeParseInt.js

@@ -23,15 +23,9 @@ __export(safeParseInt_exports, {
   safeParseInt: () => safeParseInt
 });
 module.exports = __toCommonJS(safeParseInt_exports);
-function safeParseInt(s, logError = false) {
+function safeParseInt(s, defaultValue = 0) {
   const i = Number(s);
-  if (isNaN(i)) {
-    if (logError) {
-      console.error(`Not a number: "${s}"`);
-    }
-    return 0;
-  }
-  return Math.floor(i);
+  return isNaN(i) ? defaultValue : Math.floor(i);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/safeParseInt.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/safeParseInt.ts"],"sourcesContent":["/**\n * Returns 0 if the string is not a valid number.\n *\n * @param logError Log a console error if the given string is not a valid\n *   number. Defaults to false (don't log anything).\n */\nexport function safeParseInt(s: string, logError = false): number {\n  const i = Number(s);\n\n  if (isNaN(i)) {\n    if (logError) {\n      console.error(`Not a number: \"${s}\"`);\n    }\n    return 0;\n  }\n\n  return Math.floor(i);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMO,SAAS,aAAa,GAAW,WAAW,OAAe;AAChE,QAAM,IAAI,OAAO,CAAC;AAElB,MAAI,MAAM,CAAC,GAAG;AACZ,QAAI,UAAU;AACZ,cAAQ,MAAM,kBAAkB,CAAC,GAAG;AAAA,IACtC;AACA,WAAO;AAAA,EACT;AAEA,SAAO,KAAK,MAAM,CAAC;AACrB;","names":[]}
+{"version":3,"sources":["../src/safeParseInt.ts"],"sourcesContent":["/**\n * Returns 0 or the given defaultValue if the string is not a valid number.\n */\nexport function safeParseInt<T>(\n  s: string,\n  defaultValue: T | number = 0,\n): T | number {\n  const i = Number(s);\n  return isNaN(i) ? defaultValue : Math.floor(i);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,SAAS,aACd,GACA,eAA2B,GACf;AACZ,QAAM,IAAI,OAAO,CAAC;AAClB,SAAO,MAAM,CAAC,IAAI,eAAe,KAAK,MAAM,CAAC;AAC/C;","names":[]}

package/src/round.ts

@@ -0,0 +1,18 @@
+/**
+ * Simplifies rounding of floating point numbers. Note that if your number ends
+ * with zeros, and you convert the number to string, you will lose the zeroes
+ * at the end. To show the exact number of decimal places, you'll need to use
+ * toFixed(). E.g. round(1.20, 2).toFixed(2).
+ */
+export function round(n: number, numDecimalPlaces = 0): number {
+  const multipler = Math.pow(10, numDecimalPlaces);
+  return Math.round(n * multipler) / multipler;
+}
+
+/**
+ * Returns a string with the number in the exact number of decimal places
+ * specified, in case the number ends with zeroes.
+ */
+export function roundS(n: number, numDecimalPlaces = 0): string {
+  return round(n, numDecimalPlaces).toFixed(numDecimalPlaces);
+}

package/src/safeParseFloat.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns 0 or the given defaultValue if the string is not a valid number.
+ */
+export function safeParseFloat<T>(
+  s: string,
+  defaultValue: T | number = 0,
+): T | number {
+  const i = Number(s);
+  return isNaN(i) ? defaultValue : i;
+}

package/src/safeParseInt.ts

@@ -1,18 +1,10 @@
 /**
- * Returns 0 if the string is not a valid number.
- *
- * @param logError Log a console error if the given string is not a valid
- *   number. Defaults to false (don't log anything).
+ * Returns 0 or the given defaultValue if the string is not a valid number.
  */
-export function safeParseInt(s: string, logError = false): number {
+export function safeParseInt<T>(
+  s: string,
+  defaultValue: T | number = 0,
+): T | number {
   const i = Number(s);
-
-  if (isNaN(i)) {
-    if (logError) {
-      console.error(`Not a number: "${s}"`);
-    }
-    return 0;
-  }
-
-  return Math.floor(i);
+  return isNaN(i) ? defaultValue : Math.floor(i);
 }