littoral-templates 0.3.0 → 0.4.0-rc.2

package/.editorconfig

@@ -0,0 +1,9 @@
+# Help: https://EditorConfig.org`
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_style = space
+indent_size = 4
+

package/.eslintrc.cjs

@@ -0,0 +1,15 @@
+/* eslint-env node */
+module.exports = {
+    extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
+    parser: "@typescript-eslint/parser",
+    plugins: ["@typescript-eslint"],
+    root: true,
+    rules: {
+        "@typescript-eslint/no-unused-vars": ["error", {"argsIgnorePattern": "^_"}],
+        "@typescript-eslint/ban-ts-ignore": "off",
+        "@typescript-eslint/prefer-spread": ["off"]
+    },
+    env: {
+        browser: true,
+        node: true
+    }}

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 0.4.0
+
+* Thunks returning a `Template` are now `Template`s as well.
+* The 3rd (Curried) argument of `indentWith`, and the 2nd (Curried) argument of `when` are now variadic.
+* The EOL string can now be set explicitly (with the `setEOLExplicitly` function), or be taken from the OS (with the asynchronous `setEOLFromOS` function). 
+  This EOL string is then used to insert newlines, and – to some extent – normalize them.
+* An object constant `commonIndentations` is added with the most common indentation styles: “2 spaces”, “4 spaces”, and “1 tab”.
+* The `flatten` function now splits on `/\r*\n/` rather than just `/\n/`.
+
 
 ## 0.3.0
 

package/dist/functions.d.ts

@@ -0,0 +1,70 @@
+import { Template } from "./index.js";
+/**
+ * @returns {string} - the given template joined as one string, taking care of proper newline endings.
+ */
+export declare const asString: (template: Template) => string;
+/**
+ * @returns 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>
+ * Note that the third Curried argument is variadic, so the array brackets (`[]`) can be elided.
+ *
+ * Usually, one sets up the following function constant before:
+ * <pre>
+ * const indent = indentWith("  ")
+ * </pre>
+ */
+export declare const indentWith: (singleIndentation: string) => (indentLevel?: number) => (...templates: Template[]) => string[];
+/**
+ * An enumeration of common indentation styles.
+ * Use these in a type-safe way as follows, e.g. for “1 tab”:
+ *
+ * ```
+ * const indent = indentWith(commonIndentations["1 tab"])
+ *
+ * indent([`foo`])
+ * ```
+ */
+export declare const commonIndentations: {
+    readonly "2 spaces": "  ";
+    readonly "4 spaces": "    ";
+    readonly "1 tab": "\t";
+};
+/**
+ * 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.
+ *
+ * Note that the second Curried argument is variadic, so it doesn't require array brackets (`[]`).
+ */
+export declare const when: (bool: boolean) => (...whenResults: 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[];
+//# sourceMappingURL=functions.d.ts.map

package/dist/functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,QAAQ,EAAC,MAAM,YAAY,CAAA;AAkB3C;;GAEG;AACH,eAAO,MAAM,QAAQ,aAAc,QAAQ,KAAG,MACI,CAAA;AAGlD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,UAAU,sBAAuB,MAAM,oBAClC,MAAM,oBAGM,QAAQ,EAAE,aAEnC,CAAA;AAGL;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB;;;;CAIrB,CAAA;AAGV;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,IAAI,SAAU,OAAO,sBAAqB,QAAQ,EAAE,KAAK,QAGnD,CAAA;AAGnB;;GAEG;AACH,eAAO,MAAM,mBAAmB,8BAA+B,QAAQ,yBACpC,CAAA"}

package/dist/functions.js

@@ -0,0 +1,119 @@
+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)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { repeat } from "./index.js";
+import { withEOLEnsured } from "./internals.js";
+/**
+ * “Flattens” the given template to an array of strings, each of which represent exactly one line.
+ */
+var flatten = function (template) {
+    if (typeof template === "function") {
+        return flatten(template());
+    }
+    if (Array.isArray(template)) {
+        return template.map(flatten).reduce(function (arrL, arrR) { return __spreadArray(__spreadArray([], arrL, true), arrR, true); }, []);
+    }
+    return template.split(/\r*\n/);
+};
+/**
+ * @returns {string} - the given template joined as one string, taking care of proper newline endings.
+ */
+export var asString = function (template) {
+    return flatten(template).map(withEOLEnsured).join("");
+};
+/**
+ * @returns 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>
+ * Note that the third Curried argument is variadic, so the array brackets (`[]`) can be elided.
+ *
+ * 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 prefix = repeat(singleIndentation, indentLevel);
+        var indenter = function (line) { return line.length > 0 ? (prefix + line) : line; };
+        return function () {
+            var templates = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                templates[_i] = arguments[_i];
+            }
+            return flatten(templates).map(indenter);
+        }; // Note: Template[] has type Template as well!
+    };
+};
+/**
+ * An enumeration of common indentation styles.
+ * Use these in a type-safe way as follows, e.g. for “1 tab”:
+ *
+ * ```
+ * const indent = indentWith(commonIndentations["1 tab"])
+ *
+ * indent([`foo`])
+ * ```
+ */
+export var commonIndentations = {
+    "2 spaces": "  ",
+    "4 spaces": "    ",
+    "1 tab": "\t"
+};
+/**
+ * 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.
+ *
+ * Note that the second Curried argument is variadic, so it doesn't require array brackets (`[]`).
+ */
+export var when = function (bool) {
+    return bool
+        ? function () {
+            var whenResults = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                whenResults[_i] = arguments[_i];
+            }
+            return flatten(whenResults);
+        } // (need to be explicit here, or it doesn't work – despite having specified the return type...)
+        : function (_) { 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), ""]; };
+};
+//# sourceMappingURL=functions.js.map

package/dist/functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.js","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAC,MAAM,EAAW,MAAM,YAAY,CAAA;AAC3C,OAAO,EAAC,cAAc,EAAC,MAAM,gBAAgB,CAAA;AAG7C;;GAEG;AACH,IAAM,OAAO,GAAG,UAAC,QAAkB;IAC/B,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;QACjC,OAAO,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAA;IAC9B,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,OAAO,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,UAAC,IAAI,EAAE,IAAI,IAAK,uCAAI,IAAI,SAAK,IAAI,SAAjB,CAAkB,EAAE,EAAE,CAAC,CAAA;IAC/E,CAAC;IACD,OAAO,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;AAClC,CAAC,CAAA;AAGD;;GAEG;AACH,MAAM,CAAC,IAAM,QAAQ,GAAG,UAAC,QAAkB;IACvC,OAAA,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;AAA9C,CAA8C,CAAA;AAGlD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,IAAM,UAAU,GAAG,UAAC,iBAAyB;IAChD,OAAA,UAAC,WAAuB;QAAvB,4BAAA,EAAA,eAAuB;QACpB,IAAM,MAAM,GAAG,MAAM,CAAC,iBAAiB,EAAE,WAAW,CAAC,CAAA;QACrD,IAAM,QAAQ,GAAG,UAAC,IAAY,IAAK,OAAA,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAxC,CAAwC,CAAA;QAC3E,OAAO;YAAC,mBAAwB;iBAAxB,UAAwB,EAAxB,qBAAwB,EAAxB,IAAwB;gBAAxB,8BAAwB;;YAC5B,OAAA,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC;QAAhC,CAAgC,CAAA,CAAI,8CAA8C;IAC1F,CAAC;AALD,CAKC,CAAA;AAGL;;;;;;;;;GASG;AACH,MAAM,CAAC,IAAM,kBAAkB,GAAG;IAC9B,UAAU,EAAE,IAAI;IAChB,UAAU,EAAE,MAAM;IAClB,OAAO,EAAE,IAAI;CACP,CAAA;AAGV;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,IAAM,IAAI,GAAG,UAAC,IAAa;IAC9B,OAAA,IAAI;QACA,CAAC,CAAC;YAAC,qBAA0B;iBAA1B,UAA0B,EAA1B,qBAA0B,EAA1B,IAA0B;gBAA1B,gCAA0B;;YAAK,OAAA,OAAO,CAAC,WAAW,CAAC;QAApB,CAAoB,CAAE,+FAA+F;QACvJ,CAAC,CAAC,UAAC,CAAC,IAAK,OAAA,EAAE,EAAF,CAAE;AAFf,CAEe,CAAA;AAGnB;;GAEG;AACH,MAAM,CAAC,IAAM,mBAAmB,GAAG,UAAI,YAAgC;IACnE,OAAA,UAAC,CAAI,IAAK,OAAA,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAArB,CAAqB;AAA/B,CAA+B,CAAA"}

package/dist/index.d.ts

@@ -1,69 +1,4 @@
-/**
- * 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 type Template = string | Array<Template>;
-/**
- * An alias for the {@link Template} type definition.
- * Note: this type might be deprecated and removed (per a major version) in the future.
- */
-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 {};
+export { Template, NestedString } from "./types.js";
+export { asString, indentWith, when, withNewlineAppended } from "./functions.js";
+export { commaSeparated, repeat } from "./strings.js";
 //# 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;;;;;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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAE,YAAY,EAAC,MAAM,YAAY,CAAA;AACjD,OAAO,EAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,mBAAmB,EAAC,MAAM,gBAAgB,CAAA;AAC9E,OAAO,EAAC,cAAc,EAAE,MAAM,EAAC,MAAM,cAAc,CAAA"}

package/dist/index.js

@@ -1,124 +1,3 @@
-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)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-/**
- * Polyfill/shim for ES2019's Array.prototype.flat(..).
- */
-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.)
- */
-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");
-};
-/**
- * @returns {string} - the given template joined as one string, taking care of proper newline endings.
- */
-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...
- */
-var repeat = function (str, n) {
-    var result = "";
-    while (n > 0) {
-        if (n % 2 === 1) {
-            result += str;
-        }
-        if (n > 1) {
-            str += str;
-        }
-        n >>= 1;
-    }
-    return result;
-};
-/**
- * @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.
- */
-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 ? "," : ""); });
-};
+export { asString, indentWith, when, withNewlineAppended } from "./functions.js";
+export { commaSeparated, repeat } from "./strings.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,mBAAmB,EAAC,MAAM,gBAAgB,CAAA;AAC9E,OAAO,EAAC,cAAc,EAAE,MAAM,EAAC,MAAM,cAAc,CAAA"}

package/dist/internals.d.ts

@@ -0,0 +1,23 @@
+export declare const eolStyles: {
+    readonly lf: "\n";
+    readonly crlf: "\r\n";
+};
+/**
+ * The value of the EOL string: typically, either "\n" (=LF-style, compatible with POSIX/Linux/macOS), or "\r\n" (=CRLF-style, compatible with Windows).
+ */
+export declare let eol: string;
+/**
+ * Sets the EOL to the OS-dependent value.
+ */
+export declare const setEOLFromOS: () => Promise<void>;
+/**
+ * Sets the EOL explicitly to the given value.
+ * (This is especially useful for testing.)
+ */
+export declare const setEOLExplicitly: (newEol: string) => void;
+/**
+ * Ensures that the given string ends with an EOL, adding one if necessary.
+ */
+export declare const withEOLEnsured: (str: string) => string;
+export declare const splitOnEOL: (str: string) => string[];
+//# sourceMappingURL=internals.d.ts.map

package/dist/internals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internals.d.ts","sourceRoot":"","sources":["../src/internals.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,SAAS;;;CAGZ,CAAA;AAEV;;GAEG;AACH,eAAO,IAAI,GAAG,EAAE,MAAqB,CAAA;AAGrC;;GAEG;AACH,eAAO,MAAM,YAAY,QAAa,QAAQ,IAAI,CAG5C,CAAA;AAGN;;;GAGG;AACH,eAAO,MAAM,gBAAgB,WAAY,MAAM,SAE9C,CAAA;AAKD;;GAEG;AACH,eAAO,MAAM,cAAc,QAAS,MAAM,KAAG,MAK5C,CAAA;AAKD,eAAO,MAAM,UAAU,QAAS,MAAM,KAAG,MAAM,EACtB,CAAA"}

package/dist/internals.js

@@ -0,0 +1,84 @@
+/*
+ * Note: don't export internals from {@see index.ts}!
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+export var eolStyles = {
+    lf: "\n",
+    crlf: "\r\n"
+};
+/**
+ * The value of the EOL string: typically, either "\n" (=LF-style, compatible with POSIX/Linux/macOS), or "\r\n" (=CRLF-style, compatible with Windows).
+ */
+export var eol = eolStyles.lf;
+/**
+ * Sets the EOL to the OS-dependent value.
+ */
+export var setEOLFromOS = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, import("os").then(function (os) {
+                eol = os.EOL;
+            })
+            /**
+             * Sets the EOL explicitly to the given value.
+             * (This is especially useful for testing.)
+             */
+        ];
+    });
+}); };
+/**
+ * Sets the EOL explicitly to the given value.
+ * (This is especially useful for testing.)
+ */
+export var setEOLExplicitly = function (newEol) {
+    eol = newEol;
+};
+var normalizeRegex = new RegExp(/\r*\n?$/);
+/**
+ * Ensures that the given string ends with an EOL, adding one if necessary.
+ */
+export var withEOLEnsured = function (str) {
+    var match = str.match(normalizeRegex);
+    return match === null
+        ? str // (should not happen, but OK...)
+        : (str.substring(0, match.index) + eol);
+};
+var splitRegex = new RegExp(/\r*\n/);
+export var splitOnEOL = function (str) {
+    return str.split(splitRegex);
+};
+//# sourceMappingURL=internals.js.map

package/dist/internals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internals.js","sourceRoot":"","sources":["../src/internals.ts"],"names":[],"mappings":"AAAA;;GAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,MAAM,CAAC,IAAM,SAAS,GAAG;IACrB,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,MAAM;CACN,CAAA;AAEV;;GAEG;AACH,MAAM,CAAC,IAAI,GAAG,GAAW,SAAS,CAAC,EAAE,CAAA;AAGrC;;GAEG;AACH,MAAM,CAAC,IAAM,YAAY,GAAG;;QACxB,sBAAA,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,UAAC,EAAE;gBACjB,GAAG,GAAG,EAAE,CAAC,GAAG,CAAA;YAChB,CAAC,CAAC;YAGN;;;eAGG;UANG;;KAAA,CAAA;AAGN;;;GAGG;AACH,MAAM,CAAC,IAAM,gBAAgB,GAAG,UAAC,MAAc;IAC3C,GAAG,GAAG,MAAM,CAAA;AAChB,CAAC,CAAA;AAGD,IAAM,cAAc,GAAG,IAAI,MAAM,CAAC,SAAS,CAAC,CAAA;AAE5C;;GAEG;AACH,MAAM,CAAC,IAAM,cAAc,GAAG,UAAC,GAAW;IACtC,IAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC,CAAA;IACvC,OAAO,KAAK,KAAK,IAAI;QACjB,CAAC,CAAC,GAAG,CAAG,iCAAiC;QACzC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAA;AAC/C,CAAC,CAAA;AAGD,IAAM,UAAU,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,CAAA;AAEtC,MAAM,CAAC,IAAM,UAAU,GAAG,UAAC,GAAW;IAClC,OAAA,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC;AAArB,CAAqB,CAAA"}

package/dist/strings.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @return the given array of strings but with commas added after each string except the last one.
+ */
+export declare const commaSeparated: (strings: string[]) => string[];
+/**
+ * Polyfill/shim for ES2015's String.prototype.repeat which doesn't work for some reason in the test...
+ * (Implementation uses the binary representation of n.)
+ */
+export declare const repeat: (str: string, n: number) => string;
+//# sourceMappingURL=strings.d.ts.map

package/dist/strings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../src/strings.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,cAAc,YAAa,MAAM,EAAE,aACiC,CAAA;AAEjF;;;GAGG;AACH,eAAO,MAAM,MAAM,QAAS,MAAM,KAAK,MAAM,KAAG,MAY/C,CAAA"}

package/dist/strings.js

@@ -0,0 +1,25 @@
+/**
+ * @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 ? "," : ""); });
+};
+/**
+ * Polyfill/shim for ES2015's String.prototype.repeat which doesn't work for some reason in the test...
+ * (Implementation uses the binary representation of n.)
+ */
+export var repeat = function (str, n) {
+    var result = "";
+    while (n > 0) {
+        if (n % 2 === 1) {
+            result += str;
+        }
+        if (n > 1) {
+            str += str;
+        }
+        n >>= 1;
+    }
+    return result;
+};
+// TODO  more common string utils, e.g. withFirst{Upper|Lower}, etc.
+//# sourceMappingURL=strings.js.map

package/dist/strings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.js","sourceRoot":"","sources":["../src/strings.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,IAAM,cAAc,GAAG,UAAC,OAAiB;IAC5C,OAAA,OAAO,CAAC,GAAG,CAAC,UAAC,GAAG,EAAE,KAAK,IAAK,OAAA,UAAG,GAAG,SAAG,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAE,EAAhD,CAAgD,CAAC;AAA7E,CAA6E,CAAA;AAEjF;;;GAGG;AACH,MAAM,CAAC,IAAM,MAAM,GAAG,UAAC,GAAW,EAAE,CAAS;IACzC,IAAI,MAAM,GAAG,EAAE,CAAA;IACf,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACX,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACd,MAAM,IAAI,GAAG,CAAA;QACjB,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACR,GAAG,IAAI,GAAG,CAAA;QACd,CAAC;QACD,CAAC,KAAK,CAAC,CAAA;IACX,CAAC;IACD,OAAO,MAAM,CAAA;AACjB,CAAC,CAAA;AAGD,oEAAoE"}

package/dist/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A type definition for “templates” that consist of a string, or an array of templates, or a thunk returning a template.
+ * Note that nesting can occur to arbitrary (finite) depth.
+ *
+ * @since version 0.3.0
+ */
+export type Template = string | Array<Template> | (() => Template);
+/**
+ * An alias for the {@link Template} type definition.
+ * Note: this type might be deprecated and removed (per a major version) in the future.
+ */
+export type NestedString = Template;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,QAAQ,CAAC,CAAA;AAElE;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAA"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,39 +1,48 @@
 {
-  "name": "littoral-templates",
-  "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": "mocha dist/test/*.js",
-    "watch-test": "mocha --watch dist/test/*.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/dslmeinte/littoral-templates.git"
-  },
-  "keywords": [
-    "template",
-    "engine"
-  ],
-  "author": "Meinte Boersma",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/dslmeinte/littoral-templates/issues"
-  },
-  "homepage": "https://github.com/dslmeinte/littoral-templates#readme",
-  "devDependencies": {
-    "@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"
-  }
+    "name": "littoral-templates",
+    "version": "0.4.0-rc.2",
+    "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 node_modules",
+        "pretest": "npm run build",
+        "test": "mocha dist/test/*.js",
+        "watch-test": "mocha --watch dist/test/*.js",
+        "lint": "eslint src",
+        "prep:pre-release": "npm run clean && npm install && npm test",
+        "prerelease": "npm run prep:pre-release",
+        "release": "npm publish",
+        "prerelease-alpha": "npm run prep:pre-release",
+        "release-alpha": "npm publish --tag beta",
+        "prerelease-beta": "npm run prep:pre-release",
+        "release-beta": "npm publish --tag beta"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/dslmeinte/littoral-templates.git"
+    },
+    "keywords": [
+        "template",
+        "engine"
+    ],
+    "author": "Meinte Boersma",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/dslmeinte/littoral-templates/issues"
+    },
+    "homepage": "https://github.com/dslmeinte/littoral-templates#readme",
+    "devDependencies": {
+        "@types/chai": "5.2.2",
+        "@types/mocha": "10.0.10",
+        "@types/node": "18.19.112",
+        "@typescript-eslint/eslint-plugin": "6.21.0",
+        "@typescript-eslint/parser": "6.21.0",
+        "chai": "5.2.0",
+        "mocha": "10.8.2",
+        "typescript": "5.3.3"
+    }
 }