@jdeighan/coffee-utils 8.0.13 → 8.0.16

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "8.0.13",
+	"version": "8.0.16",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -55,6 +55,6 @@
 		"svelte": "^3.49.0"
 	},
 	"devDependencies": {
-		"@jdeighan/unit-tester": "^2.0.14"
+		"@jdeighan/unit-tester": "^2.0.16"
 	}
 }

package/src/coffee_utils.coffee

@@ -151,12 +151,6 @@ export isBoolean = (x) ->
 
 # ---------------------------------------------------------------------------
 
-export isNumber = (x) ->
-
-	return typeof x == 'number' || x instanceof Number
-
-# ---------------------------------------------------------------------------
-
 export isObject = (x) ->
 
 	return (typeof x == 'object') \
@@ -280,14 +274,33 @@ export isRegExp = (x) ->
 
 # ---------------------------------------------------------------------------
 
-export isInteger = (x) ->
+export isNumber = (x, hOptions={}) ->
+
+	result = (typeof x == 'number') || (x instanceof Number)
+	if result
+		if defined(hOptions.min) && (x < hOptions.min)
+			result = false
+		if defined(hOptions.max) && (x > hOptions.max)
+			result = false
+	return result
+
+# ---------------------------------------------------------------------------
+
+export isInteger = (x, hOptions={}) ->
 
 	if (typeof x == 'number')
-		return Number.isInteger(x)
-	else if (getClassName(x) == 'Number')
-		return Number.isInteger(x.valueOf())
+		result = Number.isInteger(x)
+	else if (x instanceof Number)
+		result = Number.isInteger(x.valueOf())
 	else
-		return false
+		result = false
+
+	if result
+		if defined(hOptions.min) && (x < hOptions.min)
+			result = false
+		if defined(hOptions.max) && (x > hOptions.max)
+			result = false
+	return result
 
 # ---------------------------------------------------------------------------
 

package/src/coffee_utils.js

@@ -144,11 +144,6 @@ export var isBoolean = function(x) {
   return typeof x === 'boolean';
 };
 
-// ---------------------------------------------------------------------------
-export var isNumber = function(x) {
-  return typeof x === 'number' || x instanceof Number;
-};
-
 // ---------------------------------------------------------------------------
 export var isObject = function(x) {
   return (typeof x === 'object') && !isString(x) && !isArray(x) && !isHash(x) && !isNumber(x);
@@ -280,14 +275,39 @@ export var isRegExp = function(x) {
 };
 
 // ---------------------------------------------------------------------------
-export var isInteger = function(x) {
+export var isNumber = function(x, hOptions = {}) {
+  var result;
+  result = (typeof x === 'number') || (x instanceof Number);
+  if (result) {
+    if (defined(hOptions.min) && (x < hOptions.min)) {
+      result = false;
+    }
+    if (defined(hOptions.max) && (x > hOptions.max)) {
+      result = false;
+    }
+  }
+  return result;
+};
+
+// ---------------------------------------------------------------------------
+export var isInteger = function(x, hOptions = {}) {
+  var result;
   if (typeof x === 'number') {
-    return Number.isInteger(x);
-  } else if (getClassName(x) === 'Number') {
-    return Number.isInteger(x.valueOf());
+    result = Number.isInteger(x);
+  } else if (x instanceof Number) {
+    result = Number.isInteger(x.valueOf());
   } else {
-    return false;
+    result = false;
+  }
+  if (result) {
+    if (defined(hOptions.min) && (x < hOptions.min)) {
+      result = false;
+    }
+    if (defined(hOptions.max) && (x > hOptions.max)) {
+      result = false;
+    }
   }
+  return result;
 };
 
 // ---------------------------------------------------------------------------

package/src/indent_utils.coffee

@@ -15,34 +15,45 @@ export splitPrefix = (line) ->
 	lMatches = line.match(/^(\s*)(.*)$/)
 	return [lMatches[1], lMatches[2]]
 
-# ---------------------------------------------------------------------------
-#        NOTE: Currently, only TAB indentation is supported
 # ---------------------------------------------------------------------------
 #   splitLine - separate a line into [level, line]
 
-export splitLine = (line) ->
+export splitLine = (line, oneIndent="\t") ->
 
 	[prefix, str] = splitPrefix(line)
-	return [indentLevel(prefix), str]
+	return [indentLevel(prefix, oneIndent), str]
 
 # ---------------------------------------------------------------------------
 #   indentation - return appropriate indentation string for given level
 #   export only to allow unit testing
 
-export indentation = (level) ->
+export indentation = (level, oneIndent="\t") ->
 
 	assert (level >= 0), "indentation(): negative level"
-	return '\t'.repeat(level)
+	return oneIndent.repeat(level)
 
 # ---------------------------------------------------------------------------
 #   indentLevel - determine indent level of a string
 #                 it's OK if the string is ONLY indentation
 
-export indentLevel = (line) ->
+export indentLevel = (line, oneIndent="\t") ->
+
+	len = oneIndent.length
+
+	# --- This will always match
+	if lMatches = line.match(/^(\s*)/)
+		prefix = lMatches[1]
+		prefixLen = prefix.length
+
+	remain = prefixLen % len
+	if (remain != 0)
+		throw new Error("prefix #{OL(prefix)} not a mult of #{OL(oneIndent)}")
+
+	level = prefixLen / len
+	if (prefix != oneIndent.repeat(level))
+		throw new Error("prefix #{OL(prefix)} not a mult of #{OL(oneIndent)}")
 
-	assert isString(line), "indentLevel(): non-string #{OL(line)}"
-	lMatches = line.match(/^\t*/)
-	return lMatches[0].length
+	return level
 
 # ---------------------------------------------------------------------------
 #   isUndented - true iff indentLevel(line) == 0
@@ -50,19 +61,19 @@ export indentLevel = (line) ->
 export isUndented = (line) ->
 
 	assert isString(line), "non-string #{OL(line)}"
-	lMatches = line.match(/^\t*/)
+	lMatches = line.match(/^\s*/)
 	return (lMatches[0].length == 0)
 
 # ---------------------------------------------------------------------------
 #   indented - add indentation to each string in a block
 
-export indented = (input, level=1) ->
+export indented = (input, level=1, oneIndent="\t") ->
 
 	assert (level >= 0), "indented(): negative level"
 	if level == 0
 		return input
 
-	toAdd = indentation(level)
+	toAdd = indentation(level, oneIndent)
 	if isArray(input)
 		lInputLines = input
 	else
@@ -81,7 +92,7 @@ export indented = (input, level=1) ->
 #              indentation is removed
 #            - returns same type as text, i.e. either string or array
 
-export undented = (text, level=undef) ->
+export undented = (text, level=undef, oneIndent="\t") ->
 
 	if defined(level) && (level==0)
 		return text
@@ -102,7 +113,7 @@ export undented = (text, level=undef) ->
 	# --- determine what to remove from beginning of each line
 	if defined(level)
 		assert isInteger(level), "undented(): level must be an integer"
-		toRemove = indentation(level)
+		toRemove = indentation(level, oneIndent)
 	else
 		lMatches = lLines[0].match(/^\s*/)
 		toRemove = lMatches[0]
@@ -113,9 +124,8 @@ export undented = (text, level=undef) ->
 		if isEmpty(line)
 			lNewLines.push('')
 		else
-			assert (line.indexOf(toRemove)==0),
-				"undented(): Error removing '#{escapeStr(toRemove)}' \
-					from #{OL(text)}"
+			if (line.indexOf(toRemove) != 0)
+				throw new Error("remove #{OL(toRemove)} from #{OL(text)}")
 			lNewLines.push(line.substr(nToRemove))
 
 	if isString(text)

package/src/indent_utils.js

@@ -28,32 +28,42 @@ export var splitPrefix = function(line) {
   return [lMatches[1], lMatches[2]];
 };
 
-// ---------------------------------------------------------------------------
-//        NOTE: Currently, only TAB indentation is supported
 // ---------------------------------------------------------------------------
 //   splitLine - separate a line into [level, line]
-export var splitLine = function(line) {
+export var splitLine = function(line, oneIndent = "\t") {
   var prefix, str;
   [prefix, str] = splitPrefix(line);
-  return [indentLevel(prefix), str];
+  return [indentLevel(prefix, oneIndent), str];
 };
 
 // ---------------------------------------------------------------------------
 //   indentation - return appropriate indentation string for given level
 //   export only to allow unit testing
-export var indentation = function(level) {
+export var indentation = function(level, oneIndent = "\t") {
   assert(level >= 0, "indentation(): negative level");
-  return '\t'.repeat(level);
+  return oneIndent.repeat(level);
 };
 
 // ---------------------------------------------------------------------------
 //   indentLevel - determine indent level of a string
 //                 it's OK if the string is ONLY indentation
-export var indentLevel = function(line) {
-  var lMatches;
-  assert(isString(line), `indentLevel(): non-string ${OL(line)}`);
-  lMatches = line.match(/^\t*/);
-  return lMatches[0].length;
+export var indentLevel = function(line, oneIndent = "\t") {
+  var lMatches, len, level, prefix, prefixLen, remain;
+  len = oneIndent.length;
+  // --- This will always match
+  if (lMatches = line.match(/^(\s*)/)) {
+    prefix = lMatches[1];
+    prefixLen = prefix.length;
+  }
+  remain = prefixLen % len;
+  if (remain !== 0) {
+    throw new Error(`prefix ${OL(prefix)} not a mult of ${OL(oneIndent)}`);
+  }
+  level = prefixLen / len;
+  if (prefix !== oneIndent.repeat(level)) {
+    throw new Error(`prefix ${OL(prefix)} not a mult of ${OL(oneIndent)}`);
+  }
+  return level;
 };
 
 // ---------------------------------------------------------------------------
@@ -61,28 +71,28 @@ export var indentLevel = function(line) {
 export var isUndented = function(line) {
   var lMatches;
   assert(isString(line), `non-string ${OL(line)}`);
-  lMatches = line.match(/^\t*/);
+  lMatches = line.match(/^\s*/);
   return lMatches[0].length === 0;
 };
 
 // ---------------------------------------------------------------------------
 //   indented - add indentation to each string in a block
-export var indented = function(input, level = 1) {
+export var indented = function(input, level = 1, oneIndent = "\t") {
   var lInputLines, lLines, line, toAdd;
   assert(level >= 0, "indented(): negative level");
   if (level === 0) {
     return input;
   }
-  toAdd = indentation(level);
+  toAdd = indentation(level, oneIndent);
   if (isArray(input)) {
     lInputLines = input;
   } else {
     lInputLines = blockToArray(input);
   }
   lLines = (function() {
-    var i, len, results;
+    var i, len1, results;
     results = [];
-    for (i = 0, len = lInputLines.length; i < len; i++) {
+    for (i = 0, len1 = lInputLines.length; i < len1; i++) {
       line = lInputLines[i];
       if (isEmpty(line)) {
         results.push("");
@@ -100,8 +110,8 @@ export var indented = function(input, level = 1) {
 //            - unless level is set, in which case exactly that
 //              indentation is removed
 //            - returns same type as text, i.e. either string or array
-export var undented = function(text, level = undef) {
-  var i, j, lLines, lMatches, lNewLines, len, len1, line, nToRemove, toRemove;
+export var undented = function(text, level = undef, oneIndent = "\t") {
+  var i, j, lLines, lMatches, lNewLines, len1, len2, line, nToRemove, toRemove;
   if (defined(level) && (level === 0)) {
     return text;
   }
@@ -112,7 +122,7 @@ export var undented = function(text, level = undef) {
     }
   } else if (isArray(text)) {
     lLines = text;
-    for (i = 0, len = lLines.length; i < len; i++) {
+    for (i = 0, len1 = lLines.length; i < len1; i++) {
       line = lLines[i];
       assert(isString(line), "undented(): array not all strings");
     }
@@ -125,19 +135,21 @@ export var undented = function(text, level = undef) {
   // --- determine what to remove from beginning of each line
   if (defined(level)) {
     assert(isInteger(level), "undented(): level must be an integer");
-    toRemove = indentation(level);
+    toRemove = indentation(level, oneIndent);
   } else {
     lMatches = lLines[0].match(/^\s*/);
     toRemove = lMatches[0];
   }
   nToRemove = indentLevel(toRemove);
   lNewLines = [];
-  for (j = 0, len1 = lLines.length; j < len1; j++) {
+  for (j = 0, len2 = lLines.length; j < len2; j++) {
     line = lLines[j];
     if (isEmpty(line)) {
       lNewLines.push('');
     } else {
-      assert(line.indexOf(toRemove) === 0, `undented(): Error removing '${escapeStr(toRemove)}' from ${OL(text)}`);
+      if (line.indexOf(toRemove) !== 0) {
+        throw new Error(`remove ${OL(toRemove)} from ${OL(text)}`);
+      }
       lNewLines.push(line.substr(nToRemove));
     }
   }
@@ -153,10 +165,10 @@ export var undented = function(text, level = undef) {
 //             if numSpaces is not defined, then the first line
 //             that contains at least one space sets it
 export var tabify = function(str, numSpaces = undef) {
-  var _, i, lLines, len, level, prefix, prefixLen, ref, result, theRest;
+  var _, i, lLines, len1, level, prefix, prefixLen, ref, result, theRest;
   lLines = [];
   ref = blockToArray(str);
-  for (i = 0, len = ref.length; i < len; i++) {
+  for (i = 0, len1 = ref.length; i < len1; i++) {
     str = ref[i];
     [_, prefix, theRest] = str.match(/^(\s*)(.*)$/);
     prefixLen = prefix.length;