rsformat 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # RSFormat
 
-RSFormat is a string formatting/printing library for JavaScript. It offers an alternative to the string formatting and printing provided by `console.log`.
+RSFormat is a string formatting/printing library for JavaScript. It offers a minimal, yet powerful and flexible alternative to the string formatting and printing provided by `console.log`.
 
 ## Motivation
 
@@ -123,11 +123,48 @@ If you want to use the print function to output to anything other than `process.
 
 ```ts
 // Custom output example (ts)
-import { Printer } from 'rsformat-local/print';
+import { Printer } from 'rsformat/print';
 import { Writable } from 'stream';
 
 let someOutputStream: Writable = /* ... */;
 let someErrorStream: Writable = /* ... */;
 
 let { print, println, eprint, eprintln } = Printer(someOutputStream, someErrorStream);
-```
+```
+
+## A Note on Performance
+
+You might think that these utilities might have a performance impact on RSFormat's printing functions. And while they do, the functions are still consistently faster than `console.log`.
+
+A simple benchmark setup like the one below will demonstrate that `println` is more performant, even when doing things like base conversions and text alignment, compared to `console.log` logging a simple string:
+
+```js
+// benchmark.mjs
+import { println } from 'rsformat';
+
+const time = (fn, iter) => {
+    let time = Date.now();
+    while (iter-- > 0) {
+        fn();
+    }
+    return Date.now() - time;
+}
+
+let iterations = 100000;
+
+let logTime = time(() => console.log('hello'), iterations);
+let printlnTime = time(() => println('{:>+#7X}', 255), iterations);
+
+println('console.log time for {} executions: {}ms', iterations, logTime);
+println('rsformat.println time for {} executions: {}ms', iterations, printlnTime);
+```
+
+```
+> node benchmark.mjs
+...After a lot of output...
+
+console.log time for 100000 executions: 7217ms
+rsformat.println time for 100000 executions: 5900ms
+```
+
+_Tested on node.js using a Windows laptop on an Intel core I7-1360P, on battery power. Performance will vary, but this benchmark was just to show that RSFormat has no performance penalty._

package/lib/format.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.format = void 0;
-const util_1 = require("util");
+const node_util_1 = require("node:util");
 /**
  * Regex to match for possible formatting insertion points.
  * Similar to the way formatting is parsed in rust,
@@ -38,7 +38,7 @@ function format(str, ...params) {
             return '}';
         }
         // Process parameter number; increment param_counter if not included
-        let param = $param_number === undefined
+        let param = $param_number === ''
             ? params[param_counter++]
             : params[+$param_number];
         if (param === undefined) {
@@ -92,7 +92,7 @@ function format(str, ...params) {
                 }
                 break;
             case "?":
-                param = (0, util_1.inspect)(param, {
+                param = (0, node_util_1.inspect)(param, {
                     depth: Infinity,
                     colors: true,
                     compact: $pretty !== '#'

package/lib/print.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Writable } from 'stream';
+import { Writable } from 'node:stream';
 export declare function Printer(outStream?: Writable, errStream?: Writable): {
     /**
      * Print a format string to an output stream (usually process.stdout).

package/lib/print.js

@@ -1,9 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.eprintln = exports.eprint = exports.println = exports.print = exports.Printer = void 0;
+const node_process_1 = __importDefault(require("node:process"));
 const format_1 = require("./format");
-function Printer(outStream = process.stdout, errStream = process.stderr) {
+function Printer(outStream = node_process_1.default.stdout, errStream = node_process_1.default.stderr) {
     return {
         /**
          * Print a format string to an output stream (usually process.stdout).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rsformat",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Formatting/printing library for JavaScript that takes after rust's string formatting ",
   "files": [
     "lib",