paraphrase 2.0.0 → 3.1.0-rc-dcd4648

package/CHANGELOG.md

@@ -1,6 +1,25 @@
+# 3.0.0 2021-09-21
+
+## Breaking change
+
+### All exports are named
+
+```js
+import { paraphrase } from "paraphrase";
+```
+
+### Flavoured imports included
+
+Flavoured pre-made versions should be imported from main entry and not from directory.
+
+```js
+import { dollar } from "paraphrase";
+```
+
 # 2.0.0 2021-05-11
 
 ## Breaking change
 
 ### Remove compiled version.
+
 If you are using a bundler with babel, make sure you transpile this package to your liking

package/README.md

@@ -11,116 +11,143 @@ npm i paraphrase
 Creates new paraphrase method instance
 
 ```js
-const paraphrase = require('paraphrase');
+import { paraphrase } from "paraphrase";
 const phrase = paraphrase(/\${([^{}]*)}/gm); // Create a new phrase function using a RegExp match
 
-phrase('Hello, ${name}', {name: 'Martin'}); // Hello, Martin
+phrase("Hello, ${name}", { name: "Martin" }); // Hello, Martin
 ```
 
 Acceptable replacements (values) are strings and numbers
 
 ### Arguments and Options
-One or more RegExp replacers, an optional options object at the end
 
-| option | meaning | type | default
-| - | - | - | -
-| recursive | Should continue to resolve result string until replacements have been exhausted | `Boolean` | `true`
-| resolve | Should resolve dot notations within the template | `Boolean` | `true`
-| clean | Should remove unmatched template instances | `Boolean` | `false`
+One or more RegExp replacers, an optional options object at the end
 
+| option    | meaning                                                                         | type      | default |
+| --------- | ------------------------------------------------------------------------------- | --------- | ------- |
+| recursive | Should continue to resolve result string until replacements have been exhausted | `Boolean` | `true`  |
+| resolve   | Should resolve dot notations within the template                                | `Boolean` | `true`  |
+| clean     | Should remove unmatched template instances                                      | `Boolean` | `false` |
 
 ##### Multiple replacers
+
 ```js
 const phrase = paraphrase(/\${([^{}]*)}/gm, /\{{([^{}]*)}}/gm);
 
-phrase('Hello, ${firstname} {{lastname}}', {firstname: 'Martin', 'lastname': 'Prince'}); // Hello, Martin Prince
+phrase("Hello, ${firstname} {{lastname}}", {
+  firstname: "Martin",
+  lastname: "Prince",
+}); // Hello, Martin Prince
 ```
 
 ##### Dot notation resolve
+
 Treat dots as part of the key instead of notation marks
+
 ```js
-const phrase = paraphrase(/\${([^{}]*)}/gm, {resolve: false});
+const phrase = paraphrase(/\${([^{}]*)}/gm, { resolve: false });
 
-phrase('Hello, ${name} ${last.name}', {name: 'Martin', 'last.name': 'Prince'}); // Hello, Martin Prince
+phrase("Hello, ${name} ${last.name}", {
+  name: "Martin",
+  "last.name": "Prince",
+}); // Hello, Martin Prince
 ```
 
 ##### Unmatched cleanup
+
 Remove unmatched template instances from the result string
+
 ```js
-const phrase = paraphrase(/\${([^{}]*)}/gm, {clean: true});
+const phrase = paraphrase(/\${([^{}]*)}/gm, { clean: true });
 
-phrase('Hello, ${firstname} ${lastname}', {firstname: 'Martin'}); // Hello, Martin
+phrase("Hello, ${firstname} ${lastname}", { firstname: "Martin" }); // Hello, Martin
 ```
 
 ## Examples
+
 ### Objects
 
 ```js
-phrase('Hello, ${name}', {name: 'Martin'}); // Hello, Martin
+phrase("Hello, ${name}", { name: "Martin" }); // Hello, Martin
 ```
 
 ### Objects with dot notation
 
 ```js
 const user = {
-	name: {first: 'Martin', last: 'Prince'}
+  name: { first: "Martin", last: "Prince" },
 };
-phrase('Hello, ${name.first} ${name.last}', user); // Hello, Martin Prince
+phrase("Hello, ${name.first} ${name.last}", user); // Hello, Martin Prince
 ```
 
 ### Arrays
 
 ```js
-phrase('Hello, ${0} ${1}', ['Martin', 'Prince']); // Hello, Martin Prince
+phrase("Hello, ${0} ${1}", ["Martin", "Prince"]); // Hello, Martin Prince
 ```
 
 ### Spread arguments
 
 ```js
-phrase('Hello, ${0} ${1}', 'Martin', 'Prince'); // Hello, Martin Prince
+phrase("Hello, ${0} ${1}", "Martin", "Prince"); // Hello, Martin Prince
 ```
 
 ## Premade
 
 ### dollar `${...}`
+
 ```js
-const phrase = require('paraphrase/dollar');
+import { dollar as phrase } from "paraphrase";
 
-phrase('Hello, ${name}', {name: 'Martin'}); // Hello, Martin
+phrase("Hello, ${name}", { name: "Martin" }); // Hello, Martin
 ```
 
 ### double `{{...}}`
+
 ```js
-const phrase = require('paraphrase/double');
+import { double as phrase } from "paraphrase";
 
-phrase('Hello, {{name}}', {name: 'Martin'}); // Hello, Martin
+phrase("Hello, {{name}}", { name: "Martin" }); // Hello, Martin
 ```
 
 ### single `{...}`
+
 ```js
-const phrase = require('paraphrase/single');
+import { single as phrase } from "paraphrase";
 
-phrase('Hello, {name}', {name: 'Martin'}); // Hello, Martin
+phrase("Hello, {name}", { name: "Martin" }); // Hello, Martin
 ```
 
 ### percent `%{...}` (i18n style)
+
 ```js
-const phrase = require('paraphrase/percent');
+import { percent as phrase } from "paraphrase";
 
-phrase('Hello, %{name}', {name: 'Martin'}); // Hello, Martin
+phrase("Hello, %{name}", { name: "Martin" }); // Hello, Martin
 ```
 
 ### hash `#{...}` (ruby style)
+
+```js
+import { hash as phrase } from "paraphrase";
+
+phrase("Hello, #{name}", { name: "Martin" }); // Hello, Martin
+```
+
+### loose. Accommodate all of the above
+
 ```js
-const phrase = require('paraphrase/hash');
+import { loose as phrase } from 'paraphrase';
 
-phrase('Hello, #{name}', {name: 'Martin'}); // Hello, Martin
+phrase('Hello, #{name.first} {name.last}', {name: { first: 'Martin', last: 'Prince' }); // Hello, Martin Prince
 ```
 
 ## patterns
-A paraphrase instance exposes access to it's patterns array
+
+A paraphrase instance exposes view to its patterns array (immutable)
+
 ```js
-const phrase = require('paraphrase/hash');
+import { hash as phrase } from "paraphrase";
 
-phrase.patterns // [ /#{([^{}]*)}/gm ]
+phrase.patterns; // [ /#{([^{}]*)}/gm ]
 ```

package/index.js

@@ -1,88 +1,120 @@
-/**
- * @module paraphrase
- * @since 1.0.0
- */
-
-const notate = require('notate');
-
-/**
- * Valid types of results for the interpolated string
- * @private
- * @type {Array}
- * @member {String|Number}
- */
-const VALID_RESULT_TYPES = Object.seal([ 'string', 'number' ]);
-
-/**
- * Create new paraphrase method instance
- * @param  {...RegExp[]} replacers
- * @param  {Boolean}     [options.resolve=true] Should resolve dot notation within template
- * @param  {Boolean}     [options.clean=false]  Should remove unmatched template instances
- * @returns {Function} phraser function instance
- *
- * @example const phraser = paraphrase(/\${([^{}]*)}/gm);
- *
- * phraser('Hello, ${name}', {name: 'Martin'})
- */
-
-module.exports = function paraphrase(...replacers) {
-	const options = {
-		recursive: true,
-		resolve: true,
-		clean: false,
-	};
-	if (replacers.length && isObject(replacers[replacers.length - 1])) {
-		Object.assign(options, replacers.pop());
-	}
-
-	/**
-	 * phraser description
-	 * @param  {String}                 string       Template
-	 * @param  {Object|(String|number)} data         Data for filling
-	 * @param  {...(String|number)}     replacements Replacement for filling
-	 * @return {String}                              Result
-	 */
-	function phraser(string = '', data, ...replacements) {
-		if (typeof string !== 'string') {
-			throw new TypeError(`paraphrase expects first argument to be a string, got a ${typeof string} (${string})`);
-		}
-
-		if (!data) {
-			return string;
-		}
-
-		if (VALID_RESULT_TYPES.includes(typeof data)) {
-			data = [ data, ...replacements ];
-		}
-
-		/**
-		 * Replace method build with internal reference to the passed in data structure
-		 * @param  {String} haystack The full string match
-		 * @param  {String} needle   The content to identify as data member
-		 * @return {String}         Found value
-		 */
-		function replace(haystack, needle) {
-			const replacement = options.resolve ? notate(data, needle.trim()) : data[needle.trim()];
-
-			return VALID_RESULT_TYPES.includes(typeof replacement) ? replacement : options.clean ? '' : haystack;
-		}
+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);
 
-		const result = replacers.reduce((string, replacer) => string.replace(replacer, replace), string);
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  dollar: () => dollar,
+  double: () => double,
+  hash: () => hash,
+  loose: () => loose,
+  paraphrase: () => paraphrase,
+  percent: () => percent,
+  single: () => single
+});
+module.exports = __toCommonJS(src_exports);
 
-		return !options.recursive || string === result
-			?	result
-			: phraser(result, data, ...replacements)
-		;
-	}
+// src/notate/index.ts
+function notate(source, string = "") {
+  if (typeof string !== "string") {
+    throw new TypeError(
+      `Expected notation query to be a string, instead got ${typeof string} (${string})`
+    );
+  }
+  return string.split(".").reduce(
+    (previous, current) => typeof previous === "object" && previous ? previous[current] : previous,
+    source
+  );
+}
 
-	phraser.patterns = replacers;
+// src/isObject/index.ts
+var isObject = (obj) => `${obj}` === "[object Object]";
 
-	return phraser;
+// src/flavours/index.ts
+var flavours = {
+  dollar: /\${([^{}]*)}/gm,
+  double: /{{([^{}]*)}}/gm,
+  single: /{([^{}]*)}/gm,
+  hash: /#{([^{}]*)}/gm,
+  percent: /%{([^{}]*)}/gm
 };
 
-/**
- * Is this a basic object?
- * @param  {any} obj
- * @return {boolean}
- */
-const isObject = obj => `${obj}` === '[object Object]';
+// src/index.ts
+var VALID_RESULT_TYPES = Object.seal([
+  "string",
+  "number"
+]);
+function paraphrase(...patterns) {
+  const options = {
+    recursive: true,
+    resolve: true,
+    clean: false
+  };
+  if (patterns.length && isObject(patterns[patterns.length - 1])) {
+    Object.assign(options, patterns.pop());
+  }
+  Object.freeze(patterns);
+  function phraser(string = "", data, ...replacements) {
+    if (typeof string !== "string") {
+      throw new TypeError(
+        `paraphrase expects first argument to be a string, got a ${typeof string} (${string})`
+      );
+    }
+    if (!data) {
+      return string;
+    }
+    if (VALID_RESULT_TYPES.includes(typeof data)) {
+      data = [data, ...replacements];
+    }
+    function replace(haystack, needle) {
+      const replacement = options.resolve ? notate(data, needle.trim()) : data[needle.trim()];
+      return VALID_RESULT_TYPES.includes(typeof replacement) ? replacement : options.clean ? "" : haystack;
+    }
+    const result = patterns.reduce(
+      (string2, pattern) => string2.replace(pattern, replace),
+      string
+    );
+    return !options.recursive || string === result ? result : phraser(result, data, ...replacements);
+  }
+  Object.defineProperty(phraser, "patterns", {
+    get: () => patterns
+  });
+  return phraser;
+}
+var dollar = paraphrase(flavours.dollar);
+var double = paraphrase(flavours.double);
+var single = paraphrase(flavours.single);
+var percent = paraphrase(flavours.percent);
+var hash = paraphrase(flavours.hash);
+var loose = paraphrase(
+  flavours.dollar,
+  flavours.double,
+  flavours.percent,
+  flavours.hash,
+  flavours.single
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dollar,
+  double,
+  hash,
+  loose,
+  paraphrase,
+  percent,
+  single
+});

package/index.mjs

@@ -0,0 +1,88 @@
+// src/notate/index.ts
+function notate(source, string = "") {
+  if (typeof string !== "string") {
+    throw new TypeError(
+      `Expected notation query to be a string, instead got ${typeof string} (${string})`
+    );
+  }
+  return string.split(".").reduce(
+    (previous, current) => typeof previous === "object" && previous ? previous[current] : previous,
+    source
+  );
+}
+
+// src/isObject/index.ts
+var isObject = (obj) => `${obj}` === "[object Object]";
+
+// src/flavours/index.ts
+var flavours = {
+  dollar: /\${([^{}]*)}/gm,
+  double: /{{([^{}]*)}}/gm,
+  single: /{([^{}]*)}/gm,
+  hash: /#{([^{}]*)}/gm,
+  percent: /%{([^{}]*)}/gm
+};
+
+// src/index.ts
+var VALID_RESULT_TYPES = Object.seal([
+  "string",
+  "number"
+]);
+function paraphrase(...patterns) {
+  const options = {
+    recursive: true,
+    resolve: true,
+    clean: false
+  };
+  if (patterns.length && isObject(patterns[patterns.length - 1])) {
+    Object.assign(options, patterns.pop());
+  }
+  Object.freeze(patterns);
+  function phraser(string = "", data, ...replacements) {
+    if (typeof string !== "string") {
+      throw new TypeError(
+        `paraphrase expects first argument to be a string, got a ${typeof string} (${string})`
+      );
+    }
+    if (!data) {
+      return string;
+    }
+    if (VALID_RESULT_TYPES.includes(typeof data)) {
+      data = [data, ...replacements];
+    }
+    function replace(haystack, needle) {
+      const replacement = options.resolve ? notate(data, needle.trim()) : data[needle.trim()];
+      return VALID_RESULT_TYPES.includes(typeof replacement) ? replacement : options.clean ? "" : haystack;
+    }
+    const result = patterns.reduce(
+      (string2, pattern) => string2.replace(pattern, replace),
+      string
+    );
+    return !options.recursive || string === result ? result : phraser(result, data, ...replacements);
+  }
+  Object.defineProperty(phraser, "patterns", {
+    get: () => patterns
+  });
+  return phraser;
+}
+var dollar = paraphrase(flavours.dollar);
+var double = paraphrase(flavours.double);
+var single = paraphrase(flavours.single);
+var percent = paraphrase(flavours.percent);
+var hash = paraphrase(flavours.hash);
+var loose = paraphrase(
+  flavours.dollar,
+  flavours.double,
+  flavours.percent,
+  flavours.hash,
+  flavours.single
+);
+export {
+  dollar,
+  double,
+  hash,
+  loose,
+  paraphrase,
+  percent,
+  single
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paraphrase",
-  "version": "2.0.0",
+  "version": "3.1.0-rc-dcd4648",
   "description": "🧩 Create flavoured string template interpolation",
   "keywords": [
     "string",
@@ -19,20 +19,41 @@
     "url": "git+https://github.com/omrilotan/paraphrase.git"
   },
   "homepage": "https://omrilotan.com/paraphrase/",
-  "main": "index.js",
-  "browser": "index.js",
-  "scripts": {
-    "test": "mocha spec.js",
-    "lint": "eslint '**/*.js'"
+  "type": "commonjs",
+  "main": "./index.js",
+  "module": "./index.mjs",
+  "browser": "./index.mjs",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "browser": {
+        "import": "./index.mjs",
+        "require": "./index.js"
+      },
+      "node": {
+        "import": "./index.mjs",
+        "require": "./index.js"
+      },
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "default": "./index.js"
+    }
   },
-  "dependencies": {
-    "notate": "^1.1.2"
+  "types": "./types/index.d.ts",
+  "scripts": {
+    "test": "jest",
+    "format": "prettier --write .",
+    "build": "./scripts/build.sh",
+    "prepublishOnly": "npm run build"
   },
   "devDependencies": {
-    "@omrilotan/eslint-config": "^1.3.0",
-    "chai": "^4.3.4",
-    "eslint": "^7.26.0",
-    "eslint-plugin-log": "^1.2.7",
-    "mocha": "^8.4.0"
+    "@types/jest": "^29.2.3",
+    "esbuild": "^0.15.16",
+    "jest": "^29.3.1",
+    "prettier": "^2.8.0",
+    "ts-jest": "^29.0.3"
+  },
+  "publishConfig": {
+    "tag": "typescript"
   }
 }

package/types/flavours/index.d.ts

@@ -0,0 +1 @@
+export declare const flavours: Record<string, RegExp>;

package/types/index.d.ts

@@ -0,0 +1,36 @@
+interface IParaphraseOptions {
+    /**
+     * Should continue to resolve result string until replacements have been exhausted
+     */
+    recursive?: boolean;
+    /**
+     * Should resolve dot notation within template
+     */
+    resolve?: boolean;
+    /**
+     * Should remove unmatched template instances
+     */
+    clean?: boolean;
+}
+interface Parser {
+    (string: string | undefined, ...data: (Record<string, any> | string | number)[]): string;
+    patterns: RegExp[];
+}
+/**
+ * Create new paraphrase method instance
+ * @param  {...RegExp[]} replacers
+ * @param  {IParaphraseOptions} [options]
+ * @returns {Function} phraser function instance
+ *
+ * @example const phraser = paraphrase(/\${([^{}]*)}/gm);
+ *
+ * phraser('Hello, ${name}', {name: 'Martin'})
+ */
+export declare function paraphrase(...patterns: (RegExp | IParaphraseOptions)[]): Parser;
+export declare const dollar: Parser;
+export declare const double: Parser;
+export declare const single: Parser;
+export declare const percent: Parser;
+export declare const hash: Parser;
+export declare const loose: Parser;
+export {};

package/types/isObject/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Is this a basic object?
+ * @param  {any} obj
+ * @return {boolean}
+ */
+export declare const isObject: (obj: any) => boolean;

package/types/notate/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Resolve dot notation strings
+ *
+ * @param  {Object} context Object to start notation search (defaults to global scope)
+ * @param  {String} [string=''] Dot notation representation
+ * @return {Any} Whatever it finds / undefined
+ *
+ * @example
+ * const obj = {
+ *   top_level: {
+ *     nested: {
+ *       value: 'My Value'
+ *     }
+ *   }
+ * };
+ *
+ * notate(obj, 'top_level.nested.value');
+ * // 'My Value'
+ *
+ * notate(obj, 'top_level.missing.value');
+ * // undefined
+ */
+export declare function notate(source: any, string?: string): any;

package/dollar/index.js

@@ -1,15 +0,0 @@
-/**
- * @module dollar
- * @since 1.1.0
- */
-
-/**
- * A paraphraser: Replace method build with internal reference to the passed in data structure
- * @param  {String} haystack The full string match
- * @param  {String} needle   The content to identify as data member
- * @return {String}          Found value
- *
- * @example
- * dollar('Hello, ${name}', {name: 'Martin'}) // 'Hello, Martin'
- */
-module.exports = require('../')(/\${([^{}]*)}/gm);

package/double/index.js

@@ -1,15 +0,0 @@
-/**
- * @module double
- * @since 1.1.0
- */
-
-/**
- * A paraphraser: Replace method build with internal reference to the passed in data structure
- * @param  {String} haystack The full string match
- * @param  {String} needle   The content to identify as data member
- * @return {String}          Found value
- *
- * @example
- * double('Hello, {{name}}', {name: 'Martin'}) // 'Hello, Martin'
- */
-module.exports = require('../')(/{{([^{}]*)}}/gm);

package/hash/index.js

@@ -1,15 +0,0 @@
-/**
- * @module hash
- * @since 1.1.0
- */
-
-/**
- * A paraphraser: Replace method build with internal reference to the passed in data structure
- * @param  {String} haystack The full string match
- * @param  {String} needle   The content to identify as data member
- * @return {String}          Found value
- *
- * @example
- * hash('Hello, #{name}', {name: 'Martin'}) // 'Hello, Martin'
- */
-module.exports = require('../')(/#{([^{}]*)}/gm);

package/percent/index.js

@@ -1,15 +0,0 @@
-/**
- * @module percent
- * @since 1.1.0
- */
-
-/**
- * A paraphraser: Replace method build with internal reference to the passed in data structure
- * @param  {String} haystack The full string match
- * @param  {String} needle   The content to identify as data member
- * @return {String}          Found value
- *
- * @example
- * percent('Hello, %{name}', {name: 'Martin'}) // 'Hello, Martin'
- */
-module.exports = require('../')(/%{([^{}]*)}/gm);

package/single/index.js

@@ -1,15 +0,0 @@
-/**
- * @module single
- * @since 1.5.0
- */
-
-/**
- * A paraphraser: Replace method build with internal reference to the passed in data structure
- * @param  {String} haystack The full string match
- * @param  {String} needle   The content to identify as data member
- * @return {String}          Found value
- *
- * @example
- * double('Hello, {name}', {name: 'Martin'}) // 'Hello, Martin'
- */
-module.exports = require('../')(/{([^{}]*)}/gm);