littoral-templates 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,6 +1,25 @@
 # CHANGELOG
 
 
+## 0.3.0
+
+* Turn the package into an ESM module (back again).
+  (Should work with Deno in the meanwhile.)
+* Update dependencies: no impact on shipped code.
+* Add functions: `when`, `withNewlineAppended`, and `commaSeparated`.
+* Rename `NestedString` to `Template`, leaving `NestedString` as an alias.
+  This is  not a breaking change, but I might deprecate and remove `NestedString` in the future.
+* Add {T|J}SDoc.
+
+
+## 0.2.2
+
+* Fix internal `flatten` function for empty arrays.
+  + Use “fat arrow” syntax everywhere.
+* Improve unit testing setup using Mocha + Chai.
+  (No impact on shipped code.)
+
+
 ## 0.2.1
 
 * Declare as a CommonJS module again.

package/README.md

@@ -3,48 +3,155 @@
 A small JavaScript/TypeScript framework to do templating comfortably using the [template literal](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) syntax in either JavaScript or TypeScript.
 It doesn't come with its own syntax, like frameworks like [mustache](https://mustache.github.io/), and [handlebars](https://handlebarsjs.com/) do.
 
-The repository's name is a play on "temporal literals" and "littoral", begin phonetically close to "literal".
-The latter word indicates the part of a body of water (lake, sea, or ocean) that's closest to shore, usually shallow, and possibly not always entirely submerged.
-The name tries to convey that implementing templates with this framework doesn't require you to "wade too far into the water".
-
 Instead, templates look as follows:
 
 ```typescript
-import { asString, indentWith } from "littoral-templates"
+[
+    `top-level`,
+    [ `still top-level, but on a new line` ],
+    indent(1)([
+        `this is indented (1 level)`,
+        indent(2)([
+            `this is much more indented (3 levels)`
+        ])
+    ])
+]
+```
+
+Instances of the `Template` type are arrays of strings nested to an arbitrary depth/level.
+(Depth 0 corresponds to a single string).
+To convert this to a proper string, use the `asString` function, as follows:
+
+```typescript
+import {asString, indentWith} from "littoral-templates"
 
-const indent = indentWith("\t")     // with apologies to the spaces people...
+const indent = indentWith("    ")
 
 console.log(
-    asString([
-        `top-level`,
-        [ `still top-level, but on a new line` ],
-        indent(1)([
-            `this is indented (1 level)`,
-            indent(2)([
-                `this is much more indented (3 levels)`
-            ])
-        ])
-    ])
+    asString(<the template from the listing above>)
 )
-
 ```
 
-(The contents of the code above can be found in [`src/test/test-in-README.ts`](./src/test/test-in-README.ts) as well.)
 This code produces the following text on the JavaScript console:
 
 ```
 top-level
 still top-level, but on a new line
-        this is indented (1 level)
-                        this is even more indented (3 levels)
+    this is indented (1 level)
+            this is even more indented (3 levels)
+```
+
+
+### Iterating over collections
+
+A common activity in templates is to iterate over a collection and map each item to text.
+These sub-texts would then have to be joined together, and taking care of correct indentation is then usually quite a hassle.
+Using the `Template` type, you can simply use the `Array.map` function, as follows:
+
+```typescript
+import {asString, indentWith} from "littoral-templates"
+
+const indent = indentWith("    ")
+
+console.log(
+    asString([
+        `my items:`,
+        indent(1)(
+            ["foo", "bar"].map((item, index) => `item ${index + 1}: "${item}"`)
+        )
+    ])
+)
+```
+
+This code produces the following text on the JavaScript console:
+
+```
+my items:
+    item 1: foo
+    item 2: bar
+```
+
+
+### Including content conditionally
+
+Another common activity in templates is to include some content conditionally.
+This package provides the convenient `when` function for that.
+An example of its usage is as follows:
+
+```typescript
+[
+    `foo`,
+    `bar`,
+    when(n === 3)([
+        `lizard`,
+        `sfdeljknesv`
+    ])
+]
+```
 
+After applying the `asString`, and assuming the variable `n` holds the value `3`, this evaluates to:
+
+```
+foo
+bar
+lizard
+sfdeljknesv
+```
+
+In case the argument to the function call after `when(<some boolean condition>)` has side effects, you want to turn that into a thunk, as follows:
+
+```typescript
+let touched = 0
+const template = [
+    `foo`,
+    `bar`,
+    when(n === 3)(() => [
+        `${++touched}lizard`,
+        `sfdeljknesv`
+    ])
+]
 ```
 
+Using side effects inside a template can be useful to store information that's needed elsewhere in the text-to-generate.
+An example of that would be to keep track of imports that have to appear before their usage.
+
 
-## TODOs
+### Other convenience functions
 
-* Publish to NPM (including proper cleaning and ignoring).
-* Proper test set up, e.g. using `mocha` and `chai`.
-* Skip `undefined | null`s.
-* Does an alternative to `npm-run-all` exist (that's better)?
+Other convenience functions are:
+
+* `withNewlineAppended`: Wrap this around a template function (see definition below) to produce a template function that adds a newline after any item fed to the original template function.
+
+    A _template function_ is any function that produces an instance of `Template`.
+
+    An example of the usage of `withNewlineAppended` is
+
+    ```typescript
+    [1, 2, 3].map(withNewlineAppended((num) => `${num}`))
+    ```
+
+    which should produce the following text:
+
+    ```
+    1
+    
+    2
+    
+    3
+    
+    ```
+
+* `commaSeparated`: Given a list of strings, this function adds a comma after every string, except for the last one.
+
+    E.g., `commaSeparated(["1", "2", "3"])` becomes `["1,", "2,", "3"]`.
+    This is useful e.g. for rendering “pretty” import statements.
+
+    _Note_ that this only works on a list of strings, not an any instance of `Template`.
+
+
+### Package name
+
+The repository's name is a play on "temporal literals" and "littoral", begin phonetically close to "literal".
+The latter word indicates the part of a body of water (lake, sea, or ocean) that's closest to shore, usually shallow, and possibly not always entirely submerged.
+The name tries to convey that implementing templates with this framework doesn't require you to "wade too far into the water".
 

package/dist/index.d.ts

@@ -1,13 +1,69 @@
-export declare type NestedString = string | Array<NestedString>;
-declare type NestedStringFunction<T> = (_: NestedString) => T;
 /**
- * @returns {string} - the given nested string joined as one string, taking care of proper newline endings.
+ * A type definition for “templates” that consist of array of strings nested to an arbitrary depth.
+ * (Depth 0 corresponds to just a single string.)
+ *
+ * @since version 0.3.0
  */
-export declare const asString: (nestedString: NestedString) => string;
+export type Template = string | Array<Template>;
 /**
- * @returns {function} - a function to instantiate a function to indent a nested string.
- * The function always returns strings.
+ * An alias for the {@link Template} type definition.
+ * Note: this type might be deprecated and removed (per a major version) in the future.
  */
-export declare const indentWith: (singleIndentation: string) => (indentLevel?: number) => NestedStringFunction<string[]>;
+export type NestedString = Template;
+type TemplateFunction<T> = (_: Template) => T;
+/**
+ * @returns {string} - the given template joined as one string, taking care of proper newline endings.
+ */
+export declare const asString: (template: Template) => string;
+/**
+ * @returns {function} - a function to instantiate a function to indent a sub-template.
+ * The function always returns an array of strings.
+ *
+ * Its usage looks as follows:
+ * <pre>
+ * indentWith("  ")(2)([
+ *     `this is indented 2 levels`
+ * ])
+ * </pre>
+ *
+ * Usually, one sets up the following function constant before:
+ * <pre>
+ * const indent = indentWith("  ")
+ * </pre>
+ */
+export declare const indentWith: (singleIndentation: string) => (indentLevel?: number) => TemplateFunction<string[]>;
+/**
+ * Allows for the following syntax:
+ * <pre>
+ * [
+ *     when(<some boolean condition>)(
+ *      <stuff to include when boolean condition is true>
+ *     )
+ * ]
+ * </pre>
+ *
+ * and
+ *
+ * <pre>
+ * [
+ *     when(<some boolean condition>)(
+ *      () => <stuff to include when boolean condition is true>
+ *     )
+ * ]
+ * </pre>
+ *
+ * In the latter case, it's guaranteed that the thunk ({@see https://en.wikipedia.org/wiki/Thunk})
+ * is only evaluated (/run) when the boolean condition is true.
+ * That is useful in case the stuff to include produces side effects.
+ */
+export declare const when: (bool: boolean) => (whenResult: (() => Template) | Template) => Template;
+/**
+ * @return a function that composes the given template function with the action of "adding a newline after".
+ */
+export declare const withNewlineAppended: <T>(templateFunc: (t: T) => Template) => (t: T) => Template[];
+/**
+ * @return the given array of strings but with commas added after each string except the last one.
+ */
+export declare const commaSeparated: (strings: string[]) => string[];
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,oBAAY,YAAY,GAAG,MAAM,GAAG,KAAK,CAAC,YAAY,CAAC,CAAA;AAEvD,aAAK,oBAAoB,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,YAAY,KAAK,CAAC,CAAA;AA0BrD;;GAEG;AACH,eAAO,MAAM,QAAQ,iBAXK,YAAY,WAW4E,CAAA;AAoBlH;;;GAGG;AACH,eAAO,MAAM,UAAU,sBAAuB,MAAM,oBAAmB,MAAM,KAAO,qBAAqB,MAAM,EAAE,CAIhH,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAA;AAE/C;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAA;AAGnC,KAAK,gBAAgB,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,QAAQ,KAAK,CAAC,CAAA;AA6B7C;;GAEG;AACH,eAAO,MAAM,QAAQ,aAdN,QAAQ,WAc2F,CAAA;AAoBlH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,sBAAuB,MAAM,oBAClC,MAAM,KAAO,gBAAgB,CAAC,MAAM,EAAE,CAInD,CAAA;AAGL;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,IAAI,SAAU,OAAO,kBAEX,CAAC,MAAM,QAAQ,CAAC,GAAG,QAAQ,aAIQ,CAAA;AAG1D;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,SAC/D,CAAC,eAA0B,CAAA;AAGnC;;GAEG;AACH,eAAO,MAAM,cAAc,YAAa,MAAM,EAAE,aACiC,CAAA"}

package/dist/index.js

@@ -1,4 +1,3 @@
-"use strict";
 var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
         if (ar || !(i in from)) {
@@ -8,32 +7,35 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.indentWith = exports.asString = void 0;
 /**
  * Polyfill/shim for ES2019's Array.prototype.flat(..).
  */
-function flatten(nestedString) {
-    return Array.isArray(nestedString)
-        ? nestedString.map(flatten).reduce(function (arrL, arrR) { return __spreadArray(__spreadArray([], arrL, true), arrR, true); })
-        : [nestedString];
-}
+var flatten = function (template) {
+    return Array.isArray(template)
+        ? template.map(flatten).reduce(function (arrL, arrR) { return __spreadArray(__spreadArray([], arrL, true), arrR, true); }, [])
+        : [template];
+};
 /**
  * @returns {function(*=): *} - a function that maps over a single string using mapString, or an array of strings using mapStrings.
  * If an array is given, that array is completely (i.e.: recursively) flattened first, before the mapStrings function is applied.
+ * (This function is only used internally.)
  */
-function mapNestedString(mapString, mapStrings) {
-    return function (nestedString) {
-        return Array.isArray(nestedString)
-            ? mapStrings(flatten(nestedString))
-            : mapString(nestedString);
+var mapNestedString = function (mapString, mapStrings) {
+    return function (template) {
+        return Array.isArray(template)
+            ? mapStrings(flatten(template))
+            : mapString(template);
     };
-}
-var withNewlineEnsured = function (str) { return str.charAt(str.length - 1) === '\n' ? str : (str + "\n"); };
+};
+var withNewlineEnsured = function (str) {
+    return str.charAt(str.length - 1) === '\n'
+        ? str
+        : (str + "\n");
+};
 /**
- * @returns {string} - the given nested string joined as one string, taking care of proper newline endings.
+ * @returns {string} - the given template joined as one string, taking care of proper newline endings.
  */
-exports.asString = mapNestedString(withNewlineEnsured, function (strings) { return strings.map(withNewlineEnsured).join(""); });
+export var asString = mapNestedString(withNewlineEnsured, function (strings) { return strings.map(withNewlineEnsured).join(""); });
 /**
  * Polyfill/shim for ES2015's String.prototype.repeat which doesn't work for some reason in the test...
  */
@@ -51,14 +53,72 @@ var repeat = function (str, n) {
     return result;
 };
 /**
- * @returns {function} - a function to instantiate a function to indent a nested string.
- * The function always returns strings.
+ * @returns {function} - a function to instantiate a function to indent a sub-template.
+ * The function always returns an array of strings.
+ *
+ * Its usage looks as follows:
+ * <pre>
+ * indentWith("  ")(2)([
+ *     `this is indented 2 levels`
+ * ])
+ * </pre>
+ *
+ * Usually, one sets up the following function constant before:
+ * <pre>
+ * const indent = indentWith("  ")
+ * </pre>
+ */
+export var indentWith = function (singleIndentation) {
+    return function (indentLevel) {
+        if (indentLevel === void 0) { indentLevel = 1; }
+        var indentationPrefix = repeat(singleIndentation, indentLevel);
+        var indentLine = function (str) { return str.split("\n").map(function (line) { return (line.length > 0 ? indentationPrefix : "") + line; }).join("\n"); };
+        return mapNestedString(function (string) { return [indentLine(string)]; }, function (strings) { return strings.map(indentLine); });
+    };
+};
+/**
+ * Allows for the following syntax:
+ * <pre>
+ * [
+ *     when(<some boolean condition>)(
+ *      <stuff to include when boolean condition is true>
+ *     )
+ * ]
+ * </pre>
+ *
+ * and
+ *
+ * <pre>
+ * [
+ *     when(<some boolean condition>)(
+ *      () => <stuff to include when boolean condition is true>
+ *     )
+ * ]
+ * </pre>
+ *
+ * In the latter case, it's guaranteed that the thunk ({@see https://en.wikipedia.org/wiki/Thunk})
+ * is only evaluated (/run) when the boolean condition is true.
+ * That is useful in case the stuff to include produces side effects.
  */
-var indentWith = function (singleIndentation) { return function (indentLevel) {
-    if (indentLevel === void 0) { indentLevel = 1; }
-    var indentationPrefix = repeat(singleIndentation, indentLevel);
-    var indentLine = function (str) { return str.split("\n").map(function (line) { return (line.length > 0 ? indentationPrefix : "") + line; }).join("\n"); };
-    return mapNestedString(function (string) { return [indentLine(string)]; }, function (strings) { return strings.map(indentLine); });
-}; };
-exports.indentWith = indentWith;
+export var when = function (bool) {
+    return bool
+        ? function (whenResult) {
+            return typeof whenResult === "function"
+                ? whenResult()
+                : whenResult;
+        }
+        : function (_whenResult) { return []; };
+};
+/**
+ * @return a function that composes the given template function with the action of "adding a newline after".
+ */
+export var withNewlineAppended = function (templateFunc) {
+    return function (t) { return [templateFunc(t), ""]; };
+};
+/**
+ * @return the given array of strings but with commas added after each string except the last one.
+ */
+export var commaSeparated = function (strings) {
+    return strings.map(function (str, index) { return "".concat(str).concat(index + 1 < strings.length ? "," : ""); });
+};
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAKA;;GAEG;AACH,SAAS,OAAO,CAAC,YAA0B;IACvC,OAAO,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC;QAC9B,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,UAAC,IAAI,EAAE,IAAI,IAAK,uCAAK,IAAI,SAAK,IAAI,SAAlB,CAAoB,CAAC;QACxE,CAAC,CAAC,CAAE,YAAY,CAAE,CAAA;AAC1B,CAAC;AAGD;;;GAGG;AACH,SAAS,eAAe,CAAI,SAA2B,EAAE,UAA8B;IACnF,OAAO,UAAC,YAA0B;QAC9B,OAAA,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC;YACvB,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YACnC,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC;IAF7B,CAE6B,CAAA;AACrC,CAAC;AAGD,IAAM,kBAAkB,GAAG,UAAC,GAAW,IAAa,OAAA,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAE,GAAG,GAAG,IAAI,CAAC,EAAzD,CAAyD,CAAA;AAC7G;;GAEG;AACU,QAAA,QAAQ,GAAG,eAAe,CAAC,kBAAkB,EAAE,UAAC,OAAO,IAAK,OAAA,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,EAAxC,CAAwC,CAAC,CAAA;AAGlH;;GAEG;AACH,IAAM,MAAM,GAAG,UAAC,GAAW,EAAE,CAAS;IAClC,IAAI,MAAM,GAAG,EAAE,CAAA;IACf,OAAO,CAAC,GAAG,CAAC,EAAE;QACV,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;YACb,MAAM,IAAI,GAAG,CAAA;SAChB;QACD,IAAI,CAAC,GAAG,CAAC,EAAE;YACP,GAAG,IAAI,GAAG,CAAA;SACb;QACD,CAAC,KAAK,CAAC,CAAA;KACV;IACD,OAAO,MAAM,CAAA;AACjB,CAAC,CAAA;AAED;;;GAGG;AACI,IAAM,UAAU,GAAG,UAAC,iBAAyB,IAAK,OAAA,UAAC,WAAuB;IAAvB,4BAAA,EAAA,eAAuB;IAC7E,IAAM,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,EAAE,WAAW,CAAC,CAAA;IAChE,IAAM,UAAU,GAAG,UAAC,GAAW,IAAa,OAAA,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,UAAC,IAAI,IAAK,OAAA,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,EAAjD,CAAiD,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAA3F,CAA2F,CAAA;IACvI,OAAO,eAAe,CAAC,UAAC,MAAc,IAAe,OAAA,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAApB,CAAoB,EAAE,UAAC,OAAiB,IAAK,OAAA,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,EAAvB,CAAuB,CAAC,CAAA;AAC9H,CAAC,EAJwD,CAIxD,CAAA;AAJY,QAAA,UAAU,cAItB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "littoral-templates",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "A small JavaScript/TypeScript framework to do templating comfortably using the template literal syntax in either JavaScript or TypeScript.",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
+    "watch-build": "tsc --watch",
     "clean": "rm -rf dist",
     "pretest": "npm-run-all build",
-    "test": "node dist/test/test-in-README.js"
+    "test": "mocha dist/test/*.js",
+    "watch-test": "mocha --watch dist/test/*.js"
   },
   "repository": {
     "type": "git",
@@ -25,8 +28,12 @@
   },
   "homepage": "https://github.com/dslmeinte/littoral-templates#readme",
   "devDependencies": {
-    "@types/node": "^14.18.33",
-    "npm-run-all": "^4.1.5",
-    "typescript": "^4.8.4"
+    "@types/chai": "5.0.1",
+    "@types/mocha": "10.0.9",
+    "@types/node": "18.19.64",
+    "chai": "5.1.2",
+    "mocha": "10.8.2",
+    "npm-run-all": "4.1.5",
+    "typescript": "5.6.3"
   }
 }