@d3plus/text 3.0.0-alpha.0

package/es/src/fontFamily.js

@@ -0,0 +1,24 @@
+/**
+    @const fontFamily
+    @desc The default fallback font list used for all text labels as an Array of Strings.
+    @returns {Array<string>}
+*/ export var fontFamily = [
+    "Inter",
+    "Helvetica Neue",
+    "HelveticaNeue",
+    "Helvetica",
+    "Arial",
+    "sans-serif"
+];
+/**
+    @const fontFamilyStringify
+    @desc Converts an Array of font-family names into a CSS font-family string.
+    @param {String|Array<string>} *family*
+    @returns {String}
+*/ export var fontFamilyStringify = function(family) {
+    return (typeof family === "string" ? [
+        family
+    ] : family).map(function(d) {
+        return d.match(/^[a-z-_]{1,}$/) ? d : "'".concat(d, "'");
+    }).join(", ");
+};

package/es/src/stringify.js

@@ -0,0 +1,16 @@
+/**
+    @function stringify
+    @desc Coerces value into a String.
+    @param {String} value
+*/ function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+export default function(value) {
+    if (value === void 0) value = "undefined";
+    else if (!(typeof value === "string" || _instanceof(value, String))) value = JSON.stringify(value);
+    return value;
+}

package/es/src/strip.js

@@ -0,0 +1,110 @@
+// great unicode list: http://asecuritysite.com/coding/asc2
+var diacritics = [
+    [
+        /[\300-\305]/g,
+        "A"
+    ],
+    [
+        /[\340-\345]/g,
+        "a"
+    ],
+    [
+        /[\306]/g,
+        "AE"
+    ],
+    [
+        /[\346]/g,
+        "ae"
+    ],
+    [
+        /[\337]/g,
+        "B"
+    ],
+    [
+        /[\307]/g,
+        "C"
+    ],
+    [
+        /[\347]/g,
+        "c"
+    ],
+    [
+        /[\320\336\376]/g,
+        "D"
+    ],
+    [
+        /[\360]/g,
+        "d"
+    ],
+    [
+        /[\310-\313]/g,
+        "E"
+    ],
+    [
+        /[\350-\353]/g,
+        "e"
+    ],
+    [
+        /[\314-\317]/g,
+        "I"
+    ],
+    [
+        /[\354-\357]/g,
+        "i"
+    ],
+    [
+        /[\321]/g,
+        "N"
+    ],
+    [
+        /[\361]/g,
+        "n"
+    ],
+    [
+        /[\u014c\322-\326\330]/g,
+        "O"
+    ],
+    [
+        /[\u014d\362-\366\370]/g,
+        "o"
+    ],
+    [
+        /[\u016a\331-\334]/g,
+        "U"
+    ],
+    [
+        /[\u016b\371-\374]/g,
+        "u"
+    ],
+    [
+        /[\327]/g,
+        "x"
+    ],
+    [
+        /[\335]/g,
+        "Y"
+    ],
+    [
+        /[\375\377]/g,
+        "y"
+    ]
+];
+/**
+    @function strip
+    @desc Removes all non ASCII characters from a string.
+    @param {String} value
+    @param {String} [spacer = "-"]
+*/ export default function(value) {
+    var spacer = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "-";
+    return "".concat(value).replace(/[^A-Za-z0-9\-_\u0621-\u064A]/g, function(char) {
+        if (char === " ") return spacer;
+        var ret = false;
+        for(var d = 0; d < diacritics.length; d++){
+            if (new RegExp(diacritics[d][0]).test(char)) {
+                ret = diacritics[d][1];
+                break;
+            }
+        }
+        return ret || "";
+    });
+}

package/es/src/textSplit.js

@@ -0,0 +1,76 @@
+import { default as stringify } from "./stringify.js";
+import { default as combiningMarks } from "./combiningMarks.js";
+import { merge } from "d3-array";
+var splitChars = [
+    "-",
+    ";",
+    ":",
+    "&",
+    "|",
+    "u0E2F",
+    "u0EAF",
+    "u0EC6",
+    "u0ECC",
+    "u104A",
+    "u104B",
+    "u104C",
+    "u104D",
+    "u104E",
+    "u104F",
+    "u2013",
+    "u2014",
+    "u2027",
+    "u3000",
+    "u3001",
+    "u3002",
+    "uFF0C",
+    "uFF5E" // wave dash
+];
+var prefixChars = [
+    "'",
+    "<",
+    "(",
+    "{",
+    "[",
+    "u00AB",
+    "u300A",
+    "u3008" // left angle bracket
+];
+var suffixChars = [
+    "'",
+    ">",
+    ")",
+    "}",
+    "]",
+    ".",
+    "!",
+    "?",
+    "/",
+    "u00BB",
+    "u300B",
+    "u3009" // right angle bracket
+].concat(splitChars);
+var burmeseRange = "\u1000-\u102A\u103F-\u1049\u1050-\u1055";
+var japaneseRange = "\u3040-\u309f\u30a0-\u30ff\uff00-\uff0b\uff0d-\uff5d\uff5f-\uff9f\u3400-\u4dbf";
+var chineseRange = "\u3400-\u9FBF";
+var laoRange = "\u0E81-\u0EAE\u0EB0-\u0EC4\u0EC8-\u0ECB\u0ECD-\u0EDD";
+var noSpaceRange = burmeseRange + chineseRange + japaneseRange + laoRange;
+var splitWords = new RegExp("(\\".concat(splitChars.join("|\\"), ")*[^\\s|\\").concat(splitChars.join("|\\"), "]*(\\").concat(splitChars.join("|\\"), ")*"), "g");
+var noSpaceLanguage = new RegExp("[".concat(noSpaceRange, "]"));
+var splitAllChars = new RegExp("(\\".concat(prefixChars.join("|\\"), ")*[").concat(noSpaceRange, "](\\").concat(suffixChars.join("|\\"), "|\\").concat(combiningMarks.join("|\\"), ")*|[a-z0-9]+"), "gi");
+/**
+    @function textSplit
+    @desc Splits a given sentence into an array of words.
+    @param {String} sentence
+*/ export default function(sentence) {
+    if (!noSpaceLanguage.test(sentence)) return stringify(sentence).match(splitWords).filter(function(w) {
+        return w.length;
+    });
+    return merge(stringify(sentence).match(splitWords).map(function(d) {
+        if (noSpaceLanguage.test(d)) return d.match(splitAllChars);
+        return [
+            d
+        ];
+    }));
+}
+export { prefixChars, splitChars, splitWords, suffixChars };

package/es/src/textWrap.js

@@ -0,0 +1,120 @@
+import { textWidth } from "@d3plus/dom";
+import defaultSplit from "./textSplit.js";
+import stringify from "./stringify.js";
+import { trimRight } from "./trim.js";
+/**
+    @function textWrap
+    @desc Based on the defined styles and dimensions, breaks a string into an array of strings for each line of text.
+*/ export default function() {
+    var fontFamily = "sans-serif", fontSize = 10, fontWeight = 400, height = 200, lineHeight, maxLines = null, overflow = false, split = defaultSplit, width = 200;
+    /**
+      The inner return object and wraps the text and returns the line data array.
+      @private
+  */ function textWrap(sentence) {
+        sentence = stringify(sentence);
+        if (lineHeight === void 0) lineHeight = Math.ceil(fontSize * 1.4);
+        var words = split(sentence);
+        var style = {
+            "font-family": fontFamily,
+            "font-size": fontSize,
+            "font-weight": fontWeight,
+            "line-height": lineHeight
+        };
+        var line = 1, textProg = "", truncated = false, widthProg = 0;
+        var lineData = [], sizes = textWidth(words, style), space = textWidth(" ", style);
+        for(var i = 0; i < words.length; i++){
+            var word = words[i];
+            var wordWidth = sizes[words.indexOf(word)];
+            word += sentence.slice(textProg.length + word.length).match("^( |\n)*", "g")[0];
+            if (textProg.slice(-1) === "\n" || widthProg + wordWidth > width) {
+                if (!i && !overflow) {
+                    truncated = true;
+                    break;
+                }
+                if (lineData.length >= line) lineData[line - 1] = trimRight(lineData[line - 1]);
+                line++;
+                if (lineHeight * line > height || wordWidth > width && !overflow || maxLines && line > maxLines) {
+                    truncated = true;
+                    break;
+                }
+                widthProg = 0;
+                lineData.push(word);
+            } else if (!i) lineData[0] = word;
+            else lineData[line - 1] += word;
+            textProg += word;
+            widthProg += wordWidth;
+            widthProg += word.match(/[\s]*$/g)[0].length * space;
+        }
+        return {
+            lines: lineData,
+            sentence: sentence,
+            truncated: truncated,
+            widths: textWidth(lineData, style),
+            words: words
+        };
+    }
+    /**
+      @memberof textWrap
+      @desc If *value* is specified, sets the font family accessor to the specified function or string and returns this generator. If *value* is not specified, returns the current font family.
+      @param {Function|String} [*value* = "sans-serif"]
+  */ textWrap.fontFamily = function(_) {
+        return arguments.length ? (fontFamily = _, textWrap) : fontFamily;
+    };
+    /**
+      @memberof textWrap
+      @desc If *value* is specified, sets the font size accessor to the specified function or number and returns this generator. If *value* is not specified, returns the current font size.
+      @param {Function|Number} [*value* = 10]
+  */ textWrap.fontSize = function(_) {
+        return arguments.length ? (fontSize = _, textWrap) : fontSize;
+    };
+    /**
+      @memberof textWrap
+      @desc If *value* is specified, sets the font weight accessor to the specified function or number and returns this generator. If *value* is not specified, returns the current font weight.
+      @param {Function|Number|String} [*value* = 400]
+  */ textWrap.fontWeight = function(_) {
+        return arguments.length ? (fontWeight = _, textWrap) : fontWeight;
+    };
+    /**
+      @memberof textWrap
+      @desc If *value* is specified, sets height limit to the specified value and returns this generator. If *value* is not specified, returns the current value.
+      @param {Number} [*value* = 200]
+  */ textWrap.height = function(_) {
+        return arguments.length ? (height = _, textWrap) : height;
+    };
+    /**
+      @memberof textWrap
+      @desc If *value* is specified, sets the line height accessor to the specified function or number and returns this generator. If *value* is not specified, returns the current line height accessor, which is 1.1 times the [font size](#textWrap.fontSize) by default.
+      @param {Function|Number} [*value*]
+  */ textWrap.lineHeight = function(_) {
+        return arguments.length ? (lineHeight = _, textWrap) : lineHeight;
+    };
+    /**
+      @memberof textWrap
+      @desc If *value* is specified, sets the maximum number of lines allowed when wrapping.
+      @param {Function|Number} [*value*]
+  */ textWrap.maxLines = function(_) {
+        return arguments.length ? (maxLines = _, textWrap) : maxLines;
+    };
+    /**
+      @memberof textWrap
+      @desc If *value* is specified, sets the overflow to the specified boolean and returns this generator. If *value* is not specified, returns the current overflow value.
+      @param {Boolean} [*value* = false]
+  */ textWrap.overflow = function(_) {
+        return arguments.length ? (overflow = _, textWrap) : overflow;
+    };
+    /**
+      @memberof textWrap
+      @desc If *value* is specified, sets the word split function to the specified function and returns this generator. If *value* is not specified, returns the current word split function.
+      @param {Function} [*value*] A function that, when passed a string, is expected to return that string split into an array of words to textWrap. The default split function splits strings on the following characters: `-`, `/`, `;`, `:`, `&`
+  */ textWrap.split = function(_) {
+        return arguments.length ? (split = _, textWrap) : split;
+    };
+    /**
+      @memberof textWrap
+      @desc If *value* is specified, sets width limit to the specified value and returns this generator. If *value* is not specified, returns the current value.
+      @param {Number} [*value* = 200]
+  */ textWrap.width = function(_) {
+        return arguments.length ? (width = _, textWrap) : width;
+    };
+    return textWrap;
+}

package/es/src/titleCase.js

@@ -0,0 +1,75 @@
+import { suffixChars, default as textSplit } from "./textSplit.js";
+var lowercase = [
+    "a",
+    "an",
+    "and",
+    "as",
+    "at",
+    "but",
+    "by",
+    "for",
+    "from",
+    "if",
+    "in",
+    "into",
+    "near",
+    "nor",
+    "of",
+    "on",
+    "onto",
+    "or",
+    "per",
+    "that",
+    "the",
+    "to",
+    "with",
+    "via",
+    "vs",
+    "vs."
+];
+var uppercase = [
+    "CEO",
+    "CFO",
+    "CNC",
+    "COO",
+    "CPU",
+    "GDP",
+    "HVAC",
+    "ID",
+    "IT",
+    "R&D",
+    "TV",
+    "UI"
+];
+/**
+    @function titleCase
+    @desc Capitalizes the first letter of each word in a phrase/sentence.
+    @param {String} str The string to apply the title case logic.
+*/ export default function(str) {
+    if (str === void 0) return "";
+    var smalls = lowercase.map(function(s) {
+        return s.toLowerCase();
+    });
+    var bigs = uppercase.slice();
+    bigs = bigs.concat(bigs.map(function(b) {
+        return "".concat(b, "s");
+    }));
+    var biglow = bigs.map(function(b) {
+        return b.toLowerCase();
+    });
+    var split = textSplit(str);
+    return split.map(function(s, i) {
+        if (s) {
+            var lower = s.toLowerCase();
+            var stripped = suffixChars.includes(lower.charAt(lower.length - 1)) ? lower.slice(0, -1) : lower;
+            var bigindex = biglow.indexOf(stripped);
+            if (bigindex >= 0) return bigs[bigindex];
+            else if (smalls.includes(stripped) && i !== 0 && i !== split.length - 1) return lower;
+            else return s.charAt(0).toUpperCase() + s.substr(1).toLowerCase();
+        } else return "";
+    }).reduce(function(ret, s, i) {
+        if (i && str.charAt(ret.length) === " ") ret += " ";
+        ret += s;
+        return ret;
+    }, "");
+}

package/es/src/trim.js

@@ -0,0 +1,22 @@
+/**
+    @function trim
+    @desc Cross-browser implementation of [trim](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim).
+    @param {String} str
+*/ function trim(str) {
+    return str.toString().replace(/^\s+|\s+$/g, "");
+}
+/**
+    @function trimLeft
+    @desc Cross-browser implementation of [trimLeft](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/TrimLeft).
+    @param {String} str
+*/ function trimLeft(str) {
+    return str.toString().replace(/^\s+/, "");
+}
+/**
+    @function trimRight
+    @desc Cross-browser implementation of [trimRight](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/TrimRight).
+    @param {String} str
+*/ function trimRight(str) {
+    return str.toString().replace(/\s+$/, "");
+}
+export { trim, trimLeft, trimRight };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@d3plus/text",
+  "version": "3.0.0-alpha.0",
+  "description": "A smart SVG text box with line wrapping and automatic font size scaling.",
+  "license": "MIT",
+  "type": "module",
+  "exports": "./es/index.js",
+  "browser": "./umd/d3plus-text.full.js",
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false,
+  "files": [
+    "umd",
+    "es"
+  ],
+  "homepage": "https://d3plus.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/d3plus/d3plus.git",
+    "directory": "packages/text"
+  },
+  "keywords": [
+    "text",
+    "d3",
+    "d3plus",
+    "data",
+    "visualization"
+  ],
+  "scripts": {
+    "build:esm": "node ../../scripts/build-esm.js",
+    "build:umd": "node ../../scripts/build-umd.js",
+    "dev": "node ../../scripts/dev.js",
+    "test": "eslint index.js src/**/*.js && eslint --global=it test && mocha 'test/**/*-test.js'"
+  },
+  "dependencies": {
+    "@d3plus/dom": "3.0.0-alpha.0",
+    "d3-array": "^3.2.4",
+    "d3-selection": "^3.0.0",
+    "d3-transition": "^3.0.1"
+  }
+}