@util.js/strings 0.41.6 → 0.41.7

package/dist/Strings.js

@@ -0,0 +1,115 @@
+"use strict";
+
+/**
+ * JavaScript utility methods for strings
+ * @public
+ * @class
+ */
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+var _indexOf = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/index-of"));
+var _fromCodePoint = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/string/from-code-point"));
+var _raw = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/string/raw"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/createClass"));
+var Strings = /*#__PURE__*/function () {
+  function Strings() {
+    (0, _classCallCheck2["default"])(this, Strings);
+  }
+  return (0, _createClass2["default"])(Strings, [{
+    key: "base64ToBase64Url",
+    value: function base64ToBase64Url() {
+      var _base64url;
+      return (_base64url = base64url()).fromBase64.apply(_base64url, arguments);
+    }
+  }, {
+    key: "base64UrlDecode",
+    value: function base64UrlDecode() {
+      var _base64url2;
+      return (_base64url2 = base64url()).decode.apply(_base64url2, arguments);
+    }
+  }, {
+    key: "base64UrlEncode",
+    value: function base64UrlEncode() {
+      var _base64url3;
+      return (_base64url3 = base64url()).encode.apply(_base64url3, arguments);
+    }
+  }, {
+    key: "base64UrlToBase64",
+    value: function base64UrlToBase64() {
+      var _base64url4;
+      return (_base64url4 = base64url()).toBase64.apply(_base64url4, arguments);
+    }
+  }, {
+    key: "base64UrlToBuffer",
+    value: function base64UrlToBuffer() {
+      var _base64url5;
+      return (_base64url5 = base64url()).toBuffer.apply(_base64url5, arguments);
+    }
+
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
+  }, {
+    key: "endsWith",
+    value: function endsWith(str, searchString, position) {
+      var subjectString = str.toString();
+      if (position === undefined || position > subjectString.length) position = subjectString.length;
+      position -= searchString.length;
+      var lastIndex = (0, _indexOf["default"])(subjectString).call(subjectString, searchString, position);
+      return lastIndex !== -1 && lastIndex === position;
+    }
+  }, {
+    key: "fromCharCode",
+    value: function fromCharCode() {
+      return String.fromCharCode.apply(String, arguments);
+    }
+  }, {
+    key: "fromCodePoint",
+    value: function fromCodePoint() {
+      return _fromCodePoint["default"].apply(String, arguments);
+    }
+
+    /**
+     * Returns whether the specified object is an instance of string or not.
+     *
+     * This implementation comes from a [Stack Overflow answer]{@link https://stackoverflow.com/a/9436948}.
+     *
+     * @param {Object} object - the object to test
+     * @returns {boolean} true if the specified object is an instance of string and false otherwise
+     * @public
+     * @function
+     */
+  }, {
+    key: "isString",
+    value: function isString(object) {
+      return typeof object === "string" || object instanceof String;
+    }
+  }, {
+    key: "pad",
+    value: function pad(n, width, z) {
+      z = z || "0";
+      z = z + "";
+      if (z.length > 1) throw new Error("The padding character must have a length of 1 but was " + z.length);
+      n = n + "";
+      return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
+    }
+  }, {
+    key: "raw",
+    value: function raw() {
+      return _raw["default"].apply(String, arguments);
+    }
+
+    // https://css-tricks.com/snippets/javascript/strip-html-tags-in-javascript/
+  }, {
+    key: "stripTags",
+    value: function stripTags(str) {
+      return str.replace(/(<([^>]+)>)/gi, "");
+    }
+  }]);
+}();
+module.exports = Strings;
+var dependencies = {};
+function get(dependency) {
+  return dependencies[dependency] || (dependencies[dependency] = require(dependency));
+}
+function base64url() {
+  return get("base64url");
+}

package/package.json

@@ -9,6 +9,10 @@
     "work in https://npm.runkit.com."
   ],
   "description": "JavaScript utility methods for strings",
+  "files": [
+    "dist",
+    "index.js"
+  ],
   "keywords": [
     "base64url",
     "endsWith",
@@ -34,5 +38,5 @@
     "type": "git",
     "url": "https://github.com/creemama/utiljs/tree/master/packages/utiljs-strings"
   },
-  "version": "0.41.6"
+  "version": "0.41.7"
 }

package/lib/Strings.js

@@ -1,93 +0,0 @@
-"use strict";
-
-/**
- * JavaScript utility methods for strings
- * @public
- * @class
- */
-class Strings {
-  base64ToBase64Url() {
-    return base64url().fromBase64(...arguments);
-  }
-
-  base64UrlDecode() {
-    return base64url().decode(...arguments);
-  }
-
-  base64UrlEncode() {
-    return base64url().encode(...arguments);
-  }
-
-  base64UrlToBase64() {
-    return base64url().toBase64(...arguments);
-  }
-
-  base64UrlToBuffer() {
-    return base64url().toBuffer(...arguments);
-  }
-
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
-  endsWith(str, searchString, position) {
-    const subjectString = str.toString();
-    if (position === undefined || position > subjectString.length)
-      position = subjectString.length;
-    position -= searchString.length;
-    const lastIndex = subjectString.indexOf(searchString, position);
-    return lastIndex !== -1 && lastIndex === position;
-  }
-
-  fromCharCode() {
-    return String.fromCharCode(...arguments);
-  }
-
-  fromCodePoint() {
-    return String.fromCodePoint(...arguments);
-  }
-
-  /**
-   * Returns whether the specified object is an instance of string or not.
-   *
-   * This implementation comes from a [Stack Overflow answer]{@link https://stackoverflow.com/a/9436948}.
-   *
-   * @param {Object} object - the object to test
-   * @returns {boolean} true if the specified object is an instance of string and false otherwise
-   * @public
-   * @function
-   */
-  isString(object) {
-    return typeof object === "string" || object instanceof String;
-  }
-
-  pad(n, width, z) {
-    z = z || "0";
-    z = z + "";
-    if (z.length > 1)
-      throw new Error(
-        "The padding character must have a length of 1 but was " + z.length,
-      );
-    n = n + "";
-    return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
-  }
-
-  raw() {
-    return String.raw(...arguments);
-  }
-
-  // https://css-tricks.com/snippets/javascript/strip-html-tags-in-javascript/
-  stripTags(str) {
-    return str.replace(/(<([^>]+)>)/gi, "");
-  }
-}
-
-module.exports = Strings;
-
-const dependencies = {};
-function get(dependency) {
-  return (
-    dependencies[dependency] || (dependencies[dependency] = require(dependency))
-  );
-}
-
-function base64url() {
-  return get("base64url");
-}

package/test/StringsTest.js

@@ -1,147 +0,0 @@
-"use strict";
-
-const { expect } = require("chai");
-const strings = require("..");
-
-describe("Strings", () => {
-  describe("#base64Url...", () => {
-    it("should operate normally", () => {
-      // From https://www.npmjs.com/package/base64url
-      expect(
-        strings.base64UrlEncode(
-          "ladies and gentlemen we are floating in space",
-        ),
-      ).to.equal(
-        "bGFkaWVzIGFuZCBnZW50bGVtZW4gd2UgYXJlIGZsb2F0aW5nIGluIHNwYWNl",
-      );
-      expect(
-        strings.base64UrlDecode("cmlkZTogZHJlYW1zIGJ1cm4gZG93bg"),
-      ).to.equal("ride: dreams burn down");
-      expect(
-        strings.base64ToBase64Url("qL8R4QIcQ/ZsRqOAbeRfcZhilN/MksRtDaErMA=="),
-      ).to.equal("qL8R4QIcQ_ZsRqOAbeRfcZhilN_MksRtDaErMA");
-      expect(
-        strings.base64UrlToBase64("qL8R4QIcQ_ZsRqOAbeRfcZhilN_MksRtDaErMA"),
-      ).to.equal("qL8R4QIcQ/ZsRqOAbeRfcZhilN/MksRtDaErMA==");
-      const buf = Buffer.alloc(13);
-      buf.writeUInt8(0x73, 0);
-      buf.writeUInt8(0x70, 1);
-      buf.writeUInt8(0x69, 2);
-      buf.writeUInt8(0x72, 3);
-      buf.writeUInt8(0x69, 4);
-      buf.writeUInt8(0x74, 5);
-      buf.writeUInt8(0x75, 6);
-      buf.writeUInt8(0x61, 7);
-      buf.writeUInt8(0x6c, 8);
-      buf.writeUInt8(0x69, 9);
-      buf.writeUInt8(0x7a, 10);
-      buf.writeUInt8(0x65, 11);
-      buf.writeUInt8(0x64, 12);
-      expect(
-        strings.base64UrlToBuffer("c3Bpcml0dWFsaXplZA").toString(),
-      ).to.equal(buf.toString());
-    });
-  });
-
-  describe("#endsWith()", () => {
-    it("should operate normally", () => {
-      const str = "To be, or not to be, that is the question.";
-      expect(strings.endsWith(str, "question.")).to.be.true;
-      expect(strings.endsWith(str, "to be")).to.be.false;
-      expect(strings.endsWith(str, "to be", 19)).to.be.true;
-      expect(strings.endsWith(str, "question.", -19)).to.be.false;
-    });
-    it("should return false if position is negative", () => {
-      const str = "To be, or not to be, that is the question.";
-      expect(strings.endsWith(str, "question.", -19)).to.be.false;
-    });
-    it("should thow an error when the first or second argument is missing", () => {
-      expect(() => {
-        strings.endsWith();
-      }).to.throw(TypeError);
-      expect(() => {
-        strings.endsWith("");
-      }).to.throw(TypeError);
-    });
-  });
-
-  describe("#fromCharCode(num1[, ...[, numN]])", () => {
-    it("should return a string created from a sequence of UTF-16 code units", () => {
-      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode
-      expect(strings.fromCharCode(65, 66, 67)).to.eql("ABC");
-      expect(strings.fromCharCode(0x2014)).to.eql("—");
-      expect(strings.fromCharCode(0x12014)).to.eql("—"); // The digit 1 is truncated and ignored.
-    });
-  });
-
-  describe("#isString(object)", () => {
-    it("should operate normally", () => {
-      // To enumerate the possibilites here, I used the possible return values
-      // of typeof as inspiration:
-      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof
-      expect(strings.isString("")).to.be.true;
-      expect(strings.isString("frog")).to.be.true;
-      expect(strings.isString()).to.be.false;
-      expect(strings.isString(null)).to.be.false;
-      expect(strings.isString(false)).to.be.false;
-      expect(strings.isString(0)).to.be.false;
-      expect(
-        strings.isString(() => {
-          return "";
-        }),
-      ).to.be.false;
-      expect(strings.isString({})).to.be.false;
-    });
-  });
-
-  describe("#pad(n, width, z)", () => {
-    it("should operate normally", () => {
-      expect(strings.pad("frog", 3)).to.equal("frog");
-      expect(strings.pad("frog", 4)).to.equal("frog");
-      expect(strings.pad("frog", 6)).to.equal("00frog");
-      expect(strings.pad(123456, 3)).to.equal("123456");
-      expect(strings.pad(123456, 6)).to.equal("123456");
-      expect(strings.pad(123456, 10)).to.equal("0000123456");
-      expect(strings.pad("frog", 3, 5)).to.equal("frog");
-      expect(strings.pad("frog", 4, 5)).to.equal("frog");
-      expect(strings.pad("frog", 6, 5)).to.equal("55frog");
-      expect(strings.pad(123456, 3, 5)).to.equal("123456");
-      expect(strings.pad(123456, 6, 5)).to.equal("123456");
-      expect(strings.pad(123456, 10, 5)).to.equal("5555123456");
-    });
-    it("should return the original string if width is not positive", () => {
-      expect(strings.pad("frog", 0)).to.equal("frog");
-      expect(strings.pad("frog", -3)).to.equal("frog");
-      expect(strings.pad("frog", -4)).to.equal("frog");
-      expect(strings.pad("frog", -6)).to.equal("frog");
-    });
-    it("should use a padding character of '0' when the padding character is the empty string", () => {
-      expect(strings.pad("frog", 3, "")).to.equal("frog");
-      expect(strings.pad("frog", 4, "")).to.equal("frog");
-      expect(strings.pad("frog", 6, "")).to.equal("00frog");
-      expect(strings.pad(123456, 3, "")).to.equal("123456");
-      expect(strings.pad(123456, 6, "")).to.equal("123456");
-      expect(strings.pad(123456, 10, "")).to.equal("0000123456");
-    });
-    it("should throw an error when the padding character's length is not 1", () => {
-      expect(() => {
-        strings.pad("frog", 6, 57);
-      }).to.throw(Error);
-      expect(() => {
-        strings.pad(123456, 10, 57);
-      }).to.throw(Error);
-    });
-  });
-
-  describe("#stripTags(str)", () => {
-    it("should operate normally", () => {
-      expect(strings.stripTags("frog")).to.equal("frog");
-      expect(
-        strings.stripTags('<html><>frog</html><span style=""> </span>'),
-      ).to.equal("<>frog ");
-    });
-    it("should throw an error if any argument is null", () => {
-      expect(() => strings.stripTags()).to.throw(TypeError);
-    });
-  });
-});