@jdeighan/coffee-utils 13.0.14 → 13.0.16

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "13.0.14",
+	"version": "13.0.16",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -50,13 +50,13 @@
 	},
 	"homepage": "https://github.com/johndeighan/coffee-utils#readme",
 	"dependencies": {
-		"@jdeighan/base-utils": "^2.0.9",
+		"@jdeighan/base-utils": "^2.0.12",
 		"cross-env": "^7.0.3",
 		"n-readlines": "^1.0.1",
 		"readline-sync": "^1.4.10",
 		"svelte": "^3.55.0"
 	},
 	"devDependencies": {
-		"@jdeighan/unit-tester": "^3.0.9"
+		"@jdeighan/unit-tester": "^3.0.12"
 	}
 }

package/src/block.coffee

@@ -4,72 +4,16 @@ import fs from 'fs'
 import readline from 'readline'
 
 import {assert, croak} from '@jdeighan/base-utils'
-import {blockToArray, arrayToBlock} from '@jdeighan/base-utils/utils'
+import {
+	blockToArray, arrayToBlock, toArray, toBlock,
+	} from '@jdeighan/base-utils/utils'
 import {
 	undef, pass, defined, notdefined,
 	isEmpty, isString, isArray, nonEmpty, isArrayOfStrings,
 	rtrim, OL,
 	} from '@jdeighan/coffee-utils'
 
-export {blockToArray, arrayToBlock}
-
-# ---------------------------------------------------------------------------
-#   toArray - split a block or array into lines w/o newlines
-
-export toArray = (item, option=undef) ->
-	# --- Valid options:
-	#     'noEmptyLines'
-	#     'noLeadingEmptyLines'
-
-	if isString(item)
-		lLines = item.split(/\r?\n/)
-	else if isArray(item)
-		lLines = item
-	else
-		croak "Not a string or array"
-
-	# --- We need to ensure that no strings contain newlines
-	#     and possibly remove empty lines
-	lNewLines = []
-	nonEmptyFound = false
-	for line in lLines
-		if isEmpty(line)
-			if (option == 'noEmptyLines') \
-					|| ((option == 'noLeadingEmptyLines') && ! nonEmptyFound)
-				pass
-			else
-				lNewLines.push ''
-		else if (line.indexOf("\n") > -1)
-			for substr in toArray(line)
-				if isEmpty(substr)
-					if (option == 'noEmptyLines') \
-							|| ((option == 'noLeadingEmptyLines') && ! nonEmptyFound)
-						pass
-					else
-						lNewLines.push ''
-				else
-					nonEmptyFound = true
-					lNewLines.push substr
-		else
-			nonEmptyFound = true
-			lNewLines.push line
-	return lNewLines
-
-# ---------------------------------------------------------------------------
-#   toBlock - block may have trailing whitespace
-#             but undef items are ignored
-
-export toBlock = (lLines) ->
-
-	if notdefined(lLines)
-		return undef
-	assert isArrayOfStrings(lLines),
-		"lLines is not an array of strings: #{OL(lLines)}"
-	lNewLines = []
-	for line in lLines
-		if defined(line)
-			lNewLines.push rtrim(line)
-	return lNewLines.join("\n")
+export {blockToArray, arrayToBlock, toArray, toBlock}
 
 # ---------------------------------------------------------------------------
 

package/src/block.js

@@ -11,7 +11,9 @@ import {
 
 import {
   blockToArray,
-  arrayToBlock
+  arrayToBlock,
+  toArray,
+  toBlock
 } from '@jdeighan/base-utils/utils';
 
 import {
@@ -30,75 +32,9 @@ import {
 
 export {
   blockToArray,
-  arrayToBlock
-};
-
-// ---------------------------------------------------------------------------
-//   toArray - split a block or array into lines w/o newlines
-export var toArray = function(item, option = undef) {
-  var i, j, lLines, lNewLines, len, len1, line, nonEmptyFound, ref, substr;
-  // --- Valid options:
-  //     'noEmptyLines'
-  //     'noLeadingEmptyLines'
-  if (isString(item)) {
-    lLines = item.split(/\r?\n/);
-  } else if (isArray(item)) {
-    lLines = item;
-  } else {
-    croak("Not a string or array");
-  }
-  // --- We need to ensure that no strings contain newlines
-  //     and possibly remove empty lines
-  lNewLines = [];
-  nonEmptyFound = false;
-  for (i = 0, len = lLines.length; i < len; i++) {
-    line = lLines[i];
-    if (isEmpty(line)) {
-      if ((option === 'noEmptyLines') || ((option === 'noLeadingEmptyLines') && !nonEmptyFound)) {
-        pass;
-      } else {
-        lNewLines.push('');
-      }
-    } else if (line.indexOf("\n") > -1) {
-      ref = toArray(line);
-      for (j = 0, len1 = ref.length; j < len1; j++) {
-        substr = ref[j];
-        if (isEmpty(substr)) {
-          if ((option === 'noEmptyLines') || ((option === 'noLeadingEmptyLines') && !nonEmptyFound)) {
-            pass;
-          } else {
-            lNewLines.push('');
-          }
-        } else {
-          nonEmptyFound = true;
-          lNewLines.push(substr);
-        }
-      }
-    } else {
-      nonEmptyFound = true;
-      lNewLines.push(line);
-    }
-  }
-  return lNewLines;
-};
-
-// ---------------------------------------------------------------------------
-//   toBlock - block may have trailing whitespace
-//             but undef items are ignored
-export var toBlock = function(lLines) {
-  var i, lNewLines, len, line;
-  if (notdefined(lLines)) {
-    return undef;
-  }
-  assert(isArrayOfStrings(lLines), `lLines is not an array of strings: ${OL(lLines)}`);
-  lNewLines = [];
-  for (i = 0, len = lLines.length; i < len; i++) {
-    line = lLines[i];
-    if (defined(line)) {
-      lNewLines.push(rtrim(line));
-    }
-  }
-  return lNewLines.join("\n");
+  arrayToBlock,
+  toArray,
+  toBlock
 };
 
 // ---------------------------------------------------------------------------

package/src/indent.coffee

@@ -90,32 +90,34 @@ export isUndented = (line) ->
 
 export indented = (input, level=1, oneIndent="\t") ->
 
+	# --- level can be a string, in which case it is
+	#     pre-pended to each line of input
 	if isString(level)
-		# --- level can be a string
-		if (level == "")
+		if (level == '')
 			return input
 		toAdd = level
 	else if isInteger(level)
-		assert (level >= 0), "indented(): negative level"
 		if (level == 0)
 			return input
+		assert (level > 0), "Invalid level #{OL(level)}"
 		toAdd = indentation(level, oneIndent)
 	else
-		croak "level must be a string or integer"
+		croak "Invalid level #{OL(level)}"
 
 	# --- NOTE: toArray(input) just returns input if it's an array
 	#           else it splits the string into an array of lines
-	lLines = for line in toArray(input)
+	lLines = []
+	for line in toArray(input)
 		if isEmpty(line)
-			""
+			lLines.push ''
 		else
-			"#{toAdd}#{line}"
+			lLines.push "#{toAdd}#{line}"
+
 	if isArray(input)
 		return lLines
 	else if isString(input)
 		return toBlock(lLines)
-	else
-		croak "Invalid input; #{OL(input)}"
+	croak "Invalid input; #{OL(input)}"
 
 # ---------------------------------------------------------------------------
 #   undented - string with 1st line indentation removed for each line

package/src/indent.js

@@ -102,45 +102,41 @@ export var isUndented = function(line) {
 //   indented - add indentation to each string in a block or array
 //            - returns the same type as input, i.e. array or string
 export var indented = function(input, level = 1, oneIndent = "\t") {
-  var lLines, line, toAdd;
+  var i, lLines, len1, line, ref, toAdd;
+  // --- level can be a string, in which case it is
+  //     pre-pended to each line of input
   if (isString(level)) {
-    // --- level can be a string
-    if (level === "") {
+    if (level === '') {
       return input;
     }
     toAdd = level;
   } else if (isInteger(level)) {
-    assert(level >= 0, "indented(): negative level");
     if (level === 0) {
       return input;
     }
+    assert(level > 0, `Invalid level ${OL(level)}`);
     toAdd = indentation(level, oneIndent);
   } else {
-    croak("level must be a string or integer");
+    croak(`Invalid level ${OL(level)}`);
   }
   // --- NOTE: toArray(input) just returns input if it's an array
   //           else it splits the string into an array of lines
-  lLines = (function() {
-    var i, len1, ref, results;
-    ref = toArray(input);
-    results = [];
-    for (i = 0, len1 = ref.length; i < len1; i++) {
-      line = ref[i];
-      if (isEmpty(line)) {
-        results.push("");
-      } else {
-        results.push(`${toAdd}${line}`);
-      }
+  lLines = [];
+  ref = toArray(input);
+  for (i = 0, len1 = ref.length; i < len1; i++) {
+    line = ref[i];
+    if (isEmpty(line)) {
+      lLines.push('');
+    } else {
+      lLines.push(`${toAdd}${line}`);
     }
-    return results;
-  })();
+  }
   if (isArray(input)) {
     return lLines;
   } else if (isString(input)) {
     return toBlock(lLines);
-  } else {
-    return croak(`Invalid input; ${OL(input)}`);
   }
+  return croak(`Invalid input; ${OL(input)}`);
 };
 
 // ---------------------------------------------------------------------------