pixl-cli 1.1.0 → 1.1.2

package/README.md

@@ -398,6 +398,105 @@ culpa qui officia deserunt mollit anim
 id est laborum.
 ```
 
+## Displaying Definition Lists
+
+Call `cli.defList()` to render a two-column list of labels and values inside a box.  Labels are bold by default, values are plain, and no vertical border is drawn between the columns.  Colons are added to labels automatically when needed.  Lines will automatically truncate with ellipsis as needed.
+
+```js
+const cli = require('pixl-cli');
+
+let event = {
+	id: "emm2wtlsxrtjz8v4",
+	title: "Simple Shell Test",
+	category: "general",
+	username: "admin"
+};
+
+cli.println( cli.defList([
+	[ "Event ID", event.id ],
+	[ "Title", event.title ],
+	[ "Category", event.category ],
+	[ "Author", event.username ]
+], {
+	labelStyles: ["yellow", "bold"],
+	textStyles: ["green"],
+	indent: 1
+}) );
+```
+
+This produces a definition list like this, with colors when the terminal supports them:
+
+```
+ ┌─────────────────────────────┐
+ │ Event ID: emm2wtlsxrtjz8v4  │
+ │ Title:    Simple Shell Test │
+ │ Category: general           │
+ │ Author:   admin             │
+ └─────────────────────────────┘
+```
+
+The label and value columns are left-aligned.  When the box would exceed the attached terminal width, long values are shortened with an ellipsis.  The complete label column is preserved whenever possible.  The `indent` is treated as a horizontal margin on both sides when calculating the available width.
+
+You can customize the definition list with these options:
+
+| Property Name | Description |
+|---------------|-------------|
+| `labelStyles` | An array of [chalk](https://www.npmjs.com/package/chalk) styles or functions for labels.  Defaults to `["bold"]`. |
+| `textStyles` | An array of styles or functions for values.  Defaults to `[]`. |
+| `borderStyles` | An array of styles or functions for the box border.  Defaults to `["gray"]`. |
+| `indent` | Horizontal margin in characters on both sides of the box.  Defaults to `0`. |
+| `gap` | Spaces between the label and value columns.  Defaults to `1`. |
+| `hspace` | Spaces between the content and each side of the box.  Defaults to `1`. |
+| `vspace` | Empty lines above and below the list inside the box.  Defaults to `0`. |
+
+## Displaying Dashboard Grids
+
+Call `cli.dashGrid()` to render a responsive grid of dashboard units.  Each unit contains a centered value and label, and all units have the same dimensions regardless of their content.  Pass an array of `[label, value]` pairs:
+
+```js
+const cli = require('pixl-cli');
+
+cli.println( cli.dashGrid([
+	[ "Conductors", 1 ],
+	[ "Servers", 2 ],
+	[ "Current Alerts", 0 ],
+	[ "Active Jobs", 0 ],
+	[ "Job Success Rate", "100%" ],
+	[ "Avg. Job Elapsed", "31 sec" ]
+], {
+	minCols: 3,
+	maxCols: 5,
+	gap: 1,
+	valueStyles: ["bold", "green"]
+}) );
+```
+
+At a width of 62 columns, the first row looks like this:
+
+```
+┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
+│        1         │ │        2         │ │        0         │
+│                  │ │                  │ │                  │
+│    Conductors    │ │     Servers      │ │  Current Alerts  │
+└──────────────────┘ └──────────────────┘ └──────────────────┘
+```
+
+The grid uses the current terminal width and flows additional units onto new rows.  An incomplete final row ends after its last unit.  Labels and values are limited to one line and automatically shortened with an ellipsis when necessary.  ANSI styles and emoji are measured by their terminal display width.
+
+You can customize the dashboard grid with these options:
+
+| Property Name | Description |
+|---------------|-------------|
+| `width` | Overall layout width, including horizontal margins.  Defaults to `cli.width()`, or `80` when no terminal width is available. |
+| `unitWidth` | Target outer width used to select the responsive column count.  Defaults to `20`. |
+| `minCols` | Preferred minimum number of columns.  Defaults to `3`.  Extremely narrow terminals may use fewer to avoid overflow. |
+| `maxCols` | Maximum number of columns.  Defaults to `5`. |
+| `gap` | Horizontal spaces between units and blank lines between grid rows.  Defaults to `1`. |
+| `indent` | Horizontal margin in characters on both sides of the grid.  Defaults to `0`. |
+| `valueStyles` | An array of [chalk](https://www.npmjs.com/package/chalk) styles or functions for values.  Defaults to `["bold"]`. |
+| `labelStyles` | An array of styles or functions for labels.  Defaults to `["gray"]`. |
+| `borderStyles` | An array of styles or functions for unit borders.  Defaults to `["gray"]`. |
+
 ## Displaying Tables
 
 ![Table Example](https://pixlcore.com/software/pixl-cli/table.png)
@@ -687,6 +786,8 @@ The full list of methods and objects that are imported are:
 - `yesno()`
 - `table()`
 - `box()`
+- `defList()`
+- `dashGrid()`
 - `wrap()`
 - `center()`
 - `commify()`

package/cli.js

@@ -197,6 +197,227 @@ var cli = module.exports = {
 		return output.join("\n");
 	},
 	
+	defList: function(rows, args) {
+		// Render a two-column definition list inside a box.  The labels share a
+		// common width, but there is deliberately no border between the columns.
+		var self = this;
+		if (!args) args = {};
+		
+		// Empty arrays are valid style overrides, so test for the property rather
+		// than using || here.  Labels are bold by default and values are plain.
+		var labelStyles = ('labelStyles' in args) ? args.labelStyles : ["bold"];
+		var textStyles = ('textStyles' in args) ? args.textStyles : [];
+		var borderStyles = ('borderStyles' in args) ? args.borderStyles :
+			(('styles' in args) ? args.styles : ["gray"]);
+		var hspace = ('hspace' in args) ? args.hspace : 1;
+		var vspace = args.vspace || 0;
+		
+		// Gaps are whole terminal cells.  Invalid and negative values become zero.
+		var gap = ('gap' in args) ? Math.floor(Number(args.gap)) : 1;
+		if (!isFinite(gap) || (gap < 0)) gap = 0;
+		var indent = args.indent || "";
+		if (typeof(indent) == 'number') indent = this.space(indent);
+		
+		// Normalize and style all cells before measuring them.  This allows ANSI
+		// color, custom style functions and the cli.emoji() cursor hack to coexist
+		// with the display-width calculations below.
+		var items = (rows || []).map( function(row) {
+			var label = '' + row[0];
+			var value = '' + row[1];
+			
+			// Definition lists are one item per line.  Flatten accidental newlines so
+			// a cell cannot escape its row and disturb the surrounding box.
+			label = label.replace(/\r?\n/g, ' ').replace(/\s+$/, '');
+			value = value.replace(/\r?\n/g, ' ');
+			if (!label.replace(ansiPattern, '').match(/:$/)) label += ':';
+			
+			return {
+				label: self.applyStyles(label, labelStyles),
+				value: self.applyStyles(value, textStyles)
+			};
+		} );
+		
+		var labelWidth = 0;
+		var valueWidth = 0;
+		
+		items.forEach( function(item) {
+			labelWidth = Math.max( labelWidth, stringWidth(item.label) );
+			valueWidth = Math.max( valueWidth, stringWidth(item.value) );
+		} );
+		
+		// The indent acts as a horizontal margin, so reserve it on both sides.
+		// Also reserve both box borders, both padding areas, and the requested gap
+		// separating the label and value columns.
+		var terminalWidth = this.width();
+		var contentWidth = labelWidth + gap + valueWidth;
+		
+		if (terminalWidth) {
+			var availableWidth = terminalWidth - (stringWidth(indent) * 2);
+			var availableContentWidth = Math.max(0, availableWidth - 2 - (hspace * 2));
+			contentWidth = Math.min(contentWidth, availableContentWidth);
+		}
+		
+		// Keep the complete label column whenever possible, and give all remaining
+		// room to values.  On extremely narrow terminals labels are shortened too,
+		// while still reserving one cell for a value when any room remains.
+		if (labelWidth + gap + 1 > contentWidth) {
+			labelWidth = Math.max(0, contentWidth - gap - 1);
+		}
+		valueWidth = Math.max(0, contentWidth - labelWidth - (labelWidth ? gap : 0));
+		
+		var truncate = function(text, width) {
+			// Width.truncate() preserves ANSI resets and complete emoji graphemes.
+			if (width < 1) return '';
+			return (stringWidth(text) > width) ? Width.truncate(text, width, '…') : text;
+		};
+		
+		var lines = items.map( function(item) {
+			var label = truncate(item.label, labelWidth);
+			var value = truncate(item.value, valueWidth);
+			if (!labelWidth) return value;
+			return self.pad(label, labelWidth) + self.space(gap) + value;
+		} );
+		
+		// Let box() handle the border, padding, vertical spacing and final row
+		// padding.  Passing the normalized indent keeps numeric margins consistent.
+		return this.box( lines.join("\n"), {
+			styles: borderStyles,
+			hspace: hspace,
+			vspace: vspace,
+			indent: indent
+		} );
+	},
+	
+	dashGrid: function(rows, args) {
+		// Render a responsive grid of equal-sized dashboard units.  Each unit has a
+		// centered value, a centered label, two blank spacer rows and its own border.
+		var self = this;
+		if (!rows || !rows.length) return '';
+		if (!args) args = {};
+		
+		// Normalize numeric layout options to non-negative whole terminal cells.
+		// Invalid values fall back to their documented defaults.
+		var wholeNumber = function(value, defaultValue, minimum) {
+			value = Math.floor(Number(value));
+			if (!isFinite(value)) value = defaultValue;
+			return Math.max(minimum, value);
+		};
+		
+		var targetUnitWidth = wholeNumber(args.unitWidth, 20, 5);
+		var minCols = wholeNumber(args.minCols, 3, 1);
+		var maxCols = wholeNumber(args.maxCols, 5, 1);
+		var gap = wholeNumber(args.gap, 1, 0);
+		var indent = args.indent || '';
+		if (typeof(indent) == 'number') indent = this.space(indent);
+		
+		// A maximum is a hard cap.  If conflicting limits are supplied, lower the
+		// minimum to match rather than silently exceeding the requested maximum.
+		if (minCols > maxCols) minCols = maxCols;
+		
+		// Empty style arrays are intentional overrides, so property checks are used
+		// instead of ||.  Values are bold, labels and borders are gray by default.
+		var valueStyles = ('valueStyles' in args) ? args.valueStyles : ["bold"];
+		var labelStyles = ('labelStyles' in args) ? args.labelStyles : ["gray"];
+		var borderStyles = ('borderStyles' in args) ? args.borderStyles : ["gray"];
+		
+		// An explicit width makes redirected output and tests deterministic.  When
+		// attached to a terminal, cli.width() returns process.stdout.columns.
+		var layoutWidth = ('width' in args) ?
+			wholeNumber(args.width, 80, 0) : (this.width() || 80);
+		var availableWidth = Math.max(0, layoutWidth - (stringWidth(indent) * 2));
+		if (availableWidth < 2) return '';
+		
+		// Start with the preferred responsive column count, bounded by the caller's
+		// limits and the number of units.  unitWidth is a planning target; the actual
+		// width is calculated below after horizontal gaps have been reserved.
+		var numCols = Math.floor(availableWidth / targetUnitWidth);
+		numCols = Math.max(minCols, Math.min(maxCols, numCols));
+		numCols = Math.min(numCols, rows.length);
+		
+		// Each useful unit needs five cells: two borders, two padding cells and one
+		// content cell.  On a very narrow terminal, safety takes priority over the
+		// requested minimum column count so the grid never overflows.
+		var maxFittingCols = Math.floor((availableWidth + gap) / (5 + gap));
+		maxFittingCols = Math.max(1, maxFittingCols);
+		numCols = Math.max(1, Math.min(numCols, maxFittingCols));
+		
+		// All units use the same exact outer width.  Any indivisible remainder stays
+		// unused at the right edge, including on incomplete final rows.
+		var unitWidth = Math.floor(
+			(availableWidth - ((numCols - 1) * gap)) / numCols
+		);
+		if (unitWidth < 2) return '';
+		
+		var innerWidth = unitWidth - 2;
+		var contentWidth = Math.max(0, innerWidth - 2);
+		
+		var truncate = function(text) {
+			// Preserve ANSI styles, complete graphemes and cli.emoji() sequences.
+			if (contentWidth < 1) return '';
+			return (stringWidth(text) > contentWidth) ?
+				Width.truncate(text, contentWidth, '…') : text;
+		};
+		
+		var centerCell = function(text) {
+			// Center by terminal display width rather than JavaScript string length.
+			var remain = Math.max(0, innerWidth - stringWidth(text));
+			var left = Math.floor(remain / 2);
+			return self.space(left) + text + self.space(remain - left);
+		};
+		
+		var units = rows.map( function(row) {
+			var label = ('' + row[0]).replace(/\r?\n/g, ' ');
+			var value = ('' + row[1]).replace(/\r?\n/g, ' ');
+			return {
+				label: self.applyStyles(label, labelStyles),
+				value: self.applyStyles(value, valueStyles)
+			};
+		} );
+		
+		var renderUnit = function(unit) {
+			// The interior layout is: blank, value, blank, label.
+			var top = self.applyStyles(
+				'┌' + self.repeat('─', innerWidth) + '┐', borderStyles
+			);
+			var bottom = self.applyStyles(
+				'└' + self.repeat('─', innerWidth) + '┘', borderStyles
+			);
+			var leftBorder = self.applyStyles('│', borderStyles);
+			var rightBorder = self.applyStyles('│', borderStyles);
+			var blank = leftBorder + self.space(innerWidth) + rightBorder;
+			
+			return [
+				top,
+				// blank,
+				leftBorder + centerCell(truncate(unit.value)) + rightBorder,
+				blank,
+				leftBorder + centerCell(truncate(unit.label)) + rightBorder,
+				bottom
+			];
+		};
+		
+		var output = [];
+		for (var rowIdx = 0; rowIdx < units.length; rowIdx += numCols) {
+			var gridRow = units.slice(rowIdx, rowIdx + numCols).map(renderUnit);
+			
+			// Join corresponding lines from each unit to form one complete grid row.
+			for (var lineIdx = 0; lineIdx < 6; lineIdx++) {
+				output.push(
+					indent + gridRow.map( function(unit) {
+						return unit[lineIdx];
+					} ).join(self.space(gap))
+				);
+			}
+			
+			// The same gap controls vertical blank lines between rows of units.
+			if (rowIdx + numCols < units.length) {
+				for (var gapIdx = 0; gapIdx < gap; gapIdx++) output.push('');
+			}
+		}
+		
+		return output.join("\n");
+	},
+	
 	applyStyles: function(text, styles) {
 		// apply one or more chalk styles or functions to text string
 		if (!styles) return text;
@@ -298,25 +519,12 @@ var cli = module.exports = {
 			max_col_widths[longest_col_idx]--;
 		}
 		
-		// finally prune affected columns, trying to preserve ANSI color inside column value
+		// finally prune affected columns by display width, preserving ANSI and emoji
 		rows.forEach( function(cols, idx) {
 			cols.forEach( function(col, idy) {
 				col = '' + col;
 				if (stringWidth(col) > max_col_widths[idy]) {
-					var suffix = '';
-					var prefix = '';
-					
-					while (col.match(/^(\u001b\[[^m]*?m)/)) {
-						prefix += RegExp.$1;
-						col = col.replace(/^(\u001b\[[^m]*?m)/, '');
-					}
-					
-					while (col.match(/(\u001b\[[^m]*?m)$/)) {
-						suffix = RegExp.$1 + suffix;
-						col = col.replace(/(\u001b\[[^m]*?m)$/, '');
-					}
-					
-					cols[idy] = prefix + col.substring(0, max_col_widths[idy] - 1) + '…' + suffix;
+					cols[idy] = Width.truncate(col, max_col_widths[idy], '…');
 				} // too wide
 			});
 		});
@@ -500,7 +708,7 @@ var cli = module.exports = {
 		global.Tools = Tools;
 		
 		// bind wrap functions
-		["prompt", "yesno", "table", "box", "wrap", "center", "print", "println", "verbose", "verboseln", "warn", "warnln", "die", "dieln", "loadFile", "saveFile", "appendFile"].forEach( function(func) {
+		["prompt", "yesno", "table", "box", "defList", "dashGrid", "wrap", "center", "print", "println", "verbose", "verboseln", "warn", "warnln", "die", "dieln", "loadFile", "saveFile", "appendFile"].forEach( function(func) {
 			global[func] = self[func].bind(self);
 		} );
 		

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pixl-cli",
-	"version": "1.1.0",
+	"version": "1.1.2",
 	"description": "Tools for building command-line apps for Node.js.",
 	"author": "Joseph Huckaby <jhuckaby@gmail.com>",
 	"homepage": "https://github.com/jhuckaby/pixl-cli",

package/util.js

@@ -9,7 +9,31 @@ var ansiPattern = new RegExp([
 // Split strings into user-perceived characters, including complete emoji sequences.
 var graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 
+function splitAnsiGraphemes(text) {
+	// Split a string into complete ANSI sequences and Unicode grapheme clusters.
+	// ANSI sequences are kept intact so callers can preserve them while editing text.
+	var units = [];
+	var pattern = new RegExp(ansiPattern.source, 'g');
+	var offset = 0;
+	var match = null;
+	
+	var addText = function(value) {
+		for (var item of graphemeSegmenter.segment(value)) {
+			units.push({ text: item.segment, ansi: false });
+		}
+	};
+	
+	while ((match = pattern.exec(text))) {
+		if (match.index > offset) addText( text.substring(offset, match.index) );
+		units.push({ text: match[0], ansi: true });
+		offset = pattern.lastIndex;
+	}
+	if (offset < text.length) addText( text.substring(offset) );
+	return units;
+}
+
 module.exports = {
 	ansiPattern: ansiPattern,
-	graphemeSegmenter: graphemeSegmenter
+	graphemeSegmenter: graphemeSegmenter,
+	splitAnsiGraphemes: splitAnsiGraphemes
 };

package/width.js

@@ -65,11 +65,72 @@ function widestLine(text) {
 	return width;
 }
 
+function truncate(text, width, suffix) {
+	// Truncate a string to an exact terminal display width.  Preserve complete ANSI
+	// sequences and grapheme clusters, and retain trailing SGR codes to reset styles.
+	if (typeof(text) != 'string') text = '' + text;
+	if (suffix == null) suffix = '';
+	if (stringWidth(text) <= width) return text;
+	
+	var suffixWidth = stringWidth(suffix);
+	var contentWidth = Math.max(0, width - suffixWidth);
+	var outputWidth = 0;
+	var output = '';
+	var units = Util.splitAnsiGraphemes(text);
+	var trailingAnsi = [];
+	
+	// cli.emoji() surrounds one grapheme with cursor save, restore and movement
+	// sequences.  Treat this entire construct as one display unit so truncation
+	// can never keep the save sequence while discarding its matching restore.
+	for (var idx = 0; idx <= units.length - 4; idx++) {
+		if (
+			units[idx].ansi && (units[idx].text === '\u001b7') &&
+			!units[idx + 1].ansi &&
+			units[idx + 2].ansi && (units[idx + 2].text === '\u001b8') &&
+			units[idx + 3].ansi && (units[idx + 3].text === '\u001b[2C')
+		) {
+			var emojiUnit = units.slice(idx, idx + 4).map( function(unit) {
+				return unit.text;
+			} ).join('');
+			units.splice(idx, 4, {
+				text: emojiUnit,
+				ansi: false
+			});
+		}
+	}
+	
+	for (var idx = units.length - 1; idx >= 0; idx--) {
+		if (!units[idx].ansi) break;
+		if (units[idx].text.match(/^(?:\u001B\[|\u009B)[^m]*m$/)) {
+			trailingAnsi.unshift(units[idx].text);
+		}
+	}
+	
+	for (var idx = 0, len = units.length; idx < len; idx++) {
+		var unit = units[idx];
+		if (unit.ansi) {
+			output += unit.text;
+			continue;
+		}
+		
+		var unitWidth = stringWidth(unit.text);
+		if ((outputWidth + unitWidth) > contentWidth) break;
+		output += unit.text;
+		outputWidth += unitWidth;
+	}
+	
+	// A wide grapheme may not fit the final available cell.  Pad that cell so the
+	// ellipsis still lands at the exact requested width and tables remain aligned.
+	if (outputWidth < contentWidth) output += ' '.repeat(contentWidth - outputWidth);
+	return output + suffix + trailingAnsi.join('');
+}
+
 // Preserve the compatibility aliases provided by the old CommonJS dependencies.
 stringWidth.default = stringWidth;
 widestLine.default = widestLine;
 
 module.exports = {
 	stringWidth: stringWidth,
-	widestLine: widestLine
+	widestLine: widestLine,
+	truncate: truncate
 };

package/wrap.js

@@ -2,34 +2,15 @@
 
 var Util = require('./util');
 var stringWidth = require('./width').stringWidth;
-var ansiPattern = Util.ansiPattern;
-var graphemeSegmenter = Util.graphemeSegmenter;
 
 function getWrapTokens(text) {
 	// Split text into alternating words and breakable whitespace, while preserving
 	// ANSI sequences as zero-width units in their original positions.
-	var units = [];
-	var pattern = new RegExp(ansiPattern.source, 'g');
-	var offset = 0;
-	var match = null;
-	
-	var addText = function(value) {
-		for (var item of graphemeSegmenter.segment(value)) {
-			units.push({
-				text: item.segment,
-				width: stringWidth(item.segment),
-				breakable: !!item.segment.match(/^(?:\s|\u200B)+$/u),
-				ansi: false
-			});
-		}
-	};
-	
-	while ((match = pattern.exec(text))) {
-		if (match.index > offset) addText( text.substring(offset, match.index) );
-		units.push({ text: match[0], width: 0, breakable: false, ansi: true });
-		offset = pattern.lastIndex;
-	}
-	if (offset < text.length) addText( text.substring(offset) );
+	var units = Util.splitAnsiGraphemes(text);
+	units.forEach( function(unit) {
+		unit.width = unit.ansi ? 0 : stringWidth(unit.text);
+		unit.breakable = !unit.ansi && !!unit.text.match(/^(?:\s|\u200B)+$/u);
+	} );
 	
 	var tokens = [];
 	var token = null;

package/agents/string-width/.editorconfig

@@ -1,12 +0,0 @@
-root = true
-
-[*]
-indent_style = tab
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.yml]
-indent_style = space
-indent_size = 2

package/agents/string-width/.gitattributes

@@ -1 +0,0 @@
-* text=auto eol=lf

package/agents/string-width/.github/security.md

@@ -1,3 +0,0 @@
-# Security Policy
-
-To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure.

package/agents/string-width/.github/workflows/main.yml

@@ -1,22 +0,0 @@
-name: CI
-on:
-  - push
-  - pull_request
-jobs:
-  test:
-    name: Node.js ${{ matrix.node-version }}
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        node-version:
-          - 24
-          - 22
-          - 20
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-      - run: npm install
-      - run: npm test

package/agents/string-width/index.d.ts

@@ -1,39 +0,0 @@
-export type Options = {
-	/**
-	Count [ambiguous width characters](https://www.unicode.org/reports/tr11/#Ambiguous) as having narrow width (count of 1) instead of wide width (count of 2).
-
-	@default true
-
-	> Ambiguous characters behave like wide or narrow characters depending on the context (language tag, script identification, associated font, source of data, or explicit markup; all can provide the context). __If the context cannot be established reliably, they should be treated as narrow characters by default.__
-	> - http://www.unicode.org/reports/tr11/
-	*/
-	readonly ambiguousIsNarrow?: boolean;
-
-	/**
-	Whether [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) should be counted.
-
-	@default false
-	*/
-	readonly countAnsiEscapeCodes?: boolean;
-};
-
-/**
-Get the visual width of a string - the number of columns required to display it.
-
-Some Unicode characters are [fullwidth](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms) and use double the normal width. [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) are stripped and doesn't affect the width.
-
-@example
-```
-import stringWidth from 'string-width';
-
-stringWidth('a');
-//=> 1
-
-stringWidth('古');
-//=> 2
-
-stringWidth('\u001B[1m古\u001B[22m');
-//=> 2
-```
-*/
-export default function stringWidth(string: string, options?: Options): number;