@jdeighan/coffee-utils 10.0.0 → 10.0.3

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "10.0.0",
+	"version": "10.0.3",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -12,6 +12,7 @@
 		"./log": "./src/log_utils.js",
 		"./block": "./src/block_utils.js",
 		"./indent": "./src/indent_utils.js",
+		"./html": "./src/html_utils.js",
 		"./stack": "./src/call_stack.js",
 		"./debug": "./src/debug_utils.js",
 		"./arrow": "./src/arrow.js",

package/src/SectionMap.coffee

@@ -83,37 +83,64 @@ export class SectionMap
 	#        a set name
 	#        undef (equivalent to being set to @SectionTree)
 
-	getBlock: (desc=undef, hProcs={}) ->
+	getBlock: (desc=undef, hReplacers={}) ->
 
-		debug "enter SectionMap.getBlock()", desc, hProcs
+		debug "enter SectionMap.getBlock()", desc, hReplacers
 
-		if notdefined(desc)
+		# --- desc can only be a string or an array
+		#     so, if it's a hash, then it's really the hReplacers
+		#     and the real desc is undef
+
+		if isHash(desc)
+			debug "arg 1 is hReplacers, no desc"
+			assert isEmpty(hReplacers), "invalid parms"
+			hReplacers = desc
+			desc = @lSectionTree
+		else if notdefined(desc)
+			debug "desc is entire tree"
 			desc = @lSectionTree
 
 		if isArray(desc)
+			debug "item is an array"
 			lBlocks = []
 			setName = undef
 			for item in desc
-				if isArray(item) || isSectionName(item)
-					# --- arrayToBlock() will skip undef items
-					#     so, no need to check for undef block
-					lBlocks.push @getBlock(item, hProcs)
-				else if isSetName(item)
+				subBlock = undef
+				if isSetName(item)
+					debug "set name is #{item}"
 					setName = item
-				else if isString(item)
-					lBlocks.push item   # a literal string
+				else if isSectionName(item) || isArray(item)
+					subBlock = @getBlock(item, hReplacers)
+					if defined(subBlock)
+						debug "add subBlock", subBlock
+						lBlocks.push subBlock
+					else
+						debug "subBlock is undef"
+				else if isString(item) && nonEmpty(item)
+					debug "add string", item
+					lBlocks.push item
 				else
 					croak "Bad item: #{OL(item)}"
+
 			block = arrayToBlock(lBlocks)
+			debug "block is", block
+			if defined(setName)
+				if defined(proc = hReplacers[setName])
+					block = proc(block)
+					debug "REPLACE #{setName} with", block
+				else
+					debug "NO REPLACER for #{setName}"
 		else if isSectionName(desc)
+			debug "item is a section name"
 			block = @section(desc).getBlock()
-			if defined(proc = hProcs[desc])
+			if defined(proc = hReplacers[desc])
+				debug "REPLACE #{desc}"
 				block = proc(block)
+			else
+				debug "NO REPLACER for #{desc}"
 		else if isSetName(desc)
-			# --- pass array to getBlock()
-			block = @getBlock(@hSets[desc], hProcs)
-			if defined(proc = hProcs[desc])
-				block = proc(block)
+			debug "item is a set name"
+			block = @getBlock(@hSets[desc], hReplacers)
 		else
 			croak "Bad 1st arg: #{OL(desc)}"
 		debug "return from SectionMap.getBlock()", block

package/src/SectionMap.js

@@ -114,41 +114,68 @@ export var SectionMap = class SectionMap {
   //        a section name
   //        a set name
   //        undef (equivalent to being set to @SectionTree)
-  getBlock(desc = undef, hProcs = {}) {
-    var block, i, item, lBlocks, len, proc, setName;
-    debug("enter SectionMap.getBlock()", desc, hProcs);
-    if (notdefined(desc)) {
+  getBlock(desc = undef, hReplacers = {}) {
+    var block, i, item, lBlocks, len, proc, setName, subBlock;
+    debug("enter SectionMap.getBlock()", desc, hReplacers);
+    // --- desc can only be a string or an array
+    //     so, if it's a hash, then it's really the hReplacers
+    //     and the real desc is undef
+    if (isHash(desc)) {
+      debug("arg 1 is hReplacers, no desc");
+      assert(isEmpty(hReplacers), "invalid parms");
+      hReplacers = desc;
+      desc = this.lSectionTree;
+    } else if (notdefined(desc)) {
+      debug("desc is entire tree");
       desc = this.lSectionTree;
     }
     if (isArray(desc)) {
+      debug("item is an array");
       lBlocks = [];
       setName = undef;
       for (i = 0, len = desc.length; i < len; i++) {
         item = desc[i];
-        if (isArray(item) || isSectionName(item)) {
-          // --- arrayToBlock() will skip undef items
-          //     so, no need to check for undef block
-          lBlocks.push(this.getBlock(item, hProcs));
-        } else if (isSetName(item)) {
+        subBlock = undef;
+        if (isSetName(item)) {
+          debug(`set name is ${item}`);
           setName = item;
-        } else if (isString(item)) {
-          lBlocks.push(item); // a literal string
+        } else if (isSectionName(item) || isArray(item)) {
+          subBlock = this.getBlock(item, hReplacers);
+          if (defined(subBlock)) {
+            debug("add subBlock", subBlock);
+            lBlocks.push(subBlock);
+          } else {
+            debug("subBlock is undef");
+          }
+        } else if (isString(item) && nonEmpty(item)) {
+          debug("add string", item);
+          lBlocks.push(item);
         } else {
           croak(`Bad item: ${OL(item)}`);
         }
       }
       block = arrayToBlock(lBlocks);
+      debug("block is", block);
+      if (defined(setName)) {
+        if (defined(proc = hReplacers[setName])) {
+          block = proc(block);
+          debug(`REPLACE ${setName} with`, block);
+        } else {
+          debug(`NO REPLACER for ${setName}`);
+        }
+      }
     } else if (isSectionName(desc)) {
+      debug("item is a section name");
       block = this.section(desc).getBlock();
-      if (defined(proc = hProcs[desc])) {
+      if (defined(proc = hReplacers[desc])) {
+        debug(`REPLACE ${desc}`);
         block = proc(block);
+      } else {
+        debug(`NO REPLACER for ${desc}`);
       }
     } else if (isSetName(desc)) {
-      // --- pass array to getBlock()
-      block = this.getBlock(this.hSets[desc], hProcs);
-      if (defined(proc = hProcs[desc])) {
-        block = proc(block);
-      }
+      debug("item is a set name");
+      block = this.getBlock(this.hSets[desc], hReplacers);
     } else {
       croak(`Bad 1st arg: ${OL(desc)}`);
     }

package/src/block_utils.coffee

@@ -3,7 +3,7 @@
 import fs from 'fs'
 import readline from 'readline'
 
-import {assert, error} from '@jdeighan/unit-tester/utils'
+import {assert, error, croak} from '@jdeighan/unit-tester/utils'
 import {
 	undef, defined, isEmpty, isString, isArray, nonEmpty, rtrim,
 	} from '@jdeighan/coffee-utils'

package/src/block_utils.js

@@ -6,7 +6,8 @@ import readline from 'readline';
 
 import {
   assert,
-  error
+  error,
+  croak
 } from '@jdeighan/unit-tester/utils';
 
 import {

package/src/html_utils.coffee

@@ -0,0 +1,217 @@
+# html_utils.coffee
+
+import {assert, croak} from '@jdeighan/unit-tester/utils'
+import {
+	undef, pass, words, isEmpty, nonEmpty,
+	} from '@jdeighan/coffee-utils'
+import {indented, enclose} from '@jdeighan/coffee-utils/indent'
+import {arrayToBlock} from '@jdeighan/coffee-utils/block'
+import {debug} from '@jdeighan/coffee-utils/debug'
+
+hNoEnd = {}
+for tagName in words('area base br col command embed hr img input' \
+		+ ' keygen link meta param source track wbr')
+	hNoEnd[tagName] = true
+
+# ---------------------------------------------------------------------------
+
+export parsetag = (line) ->
+
+	if lMatches = line.match(///^
+			(?:
+				([A-Za-z][A-Za-z0-9_]*)  # variable name
+				\s*
+				=
+				\s*
+				)?                       # variable is optional
+			([A-Za-z][A-Za-z0-9_]*)     # tag name
+			(?:
+				\:
+				( [a-z]+ )
+				)?
+			(\S*)                       # modifiers (class names, etc.)
+			\s*
+			(.*)                        # attributes & enclosed text
+			$///)
+		[_, varName, tagName, subtype, modifiers, rest] = lMatches
+	else
+		croak "parsetag(): Invalid HTML: '#{line}'"
+
+	# --- Handle classes - subtypes and added via .<class>
+	lClasses = []
+	if nonEmpty(subtype) && (tagName != 'svelte')
+		lClasses.push subtype
+
+	if modifiers
+		# --- currently, these are only class names
+		while lMatches = modifiers.match(///^
+				\. ([A-Za-z][A-Za-z0-9_]*)
+				///)
+			[all, className] = lMatches
+			lClasses.push className
+			modifiers = modifiers.substring(all.length)
+		if modifiers
+			croak "parsetag(): Invalid modifiers in '#{line}'"
+
+	# --- Handle attributes
+	hAttr = {}     # { name: { value: <value>, quote: <quote> }, ... }
+
+	if varName
+		hAttr['bind:this'] = {value: varName, quote: '{'}
+
+	if (tagName == 'script') && (subtype == 'startup')
+		hAttr['context'] = {value: 'module', quote: '"'}
+
+	if rest
+		while lMatches = rest.match(///^
+				(?:
+					(?:
+						(?:
+							( bind | on )          # prefix
+							:
+							)?
+						([A-Za-z][A-Za-z0-9_]*)   # attribute name
+						)
+					=
+					(?:
+						  \{ ([^}]*) \}           # attribute value
+						| " ([^"]*) "
+						| ' ([^']*) '
+						|   ([^"'\s]+)
+						)
+					|
+					\{
+					([A-Za-z][A-Za-z0-9_]*)
+					\}
+					) \s*
+				///)
+			[all, prefix, attrName, br_val, dq_val, sq_val, uq_val, ident] = lMatches
+			if ident
+				hAttr[ident] = { value: ident, shorthand: true }
+			else
+				if br_val
+					value = br_val
+					quote = '{'
+				else
+					assert ! prefix?, "prefix requires use of {...}"
+					if dq_val
+						value = dq_val
+						quote = '"'
+					else if sq_val
+						value = sq_val
+						quote = "'"
+					else
+						value = uq_val
+						quote = ''
+
+				if prefix
+					attrName = "#{prefix}:#{attrName}"
+
+				if attrName == 'class'
+					for className in value.split(/\s+/)
+						lClasses.push className
+				else
+					if hAttr.attrName?
+						croak "parsetag(): Multiple attributes named '#{attrName}'"
+					hAttr[attrName] = { value, quote }
+
+			rest = rest.substring(all.length)
+
+	# --- The rest is contained text
+	rest = rest.trim()
+	if lMatches = rest.match(///^
+			['"]
+			(.*)
+			['"]
+			$///)
+		rest = lMatches[1]
+
+	# --- Add class attribute to hAttr if there are classes
+	if (lClasses.length > 0)
+		hAttr.class = {
+			value: lClasses.join(' '),
+			quote: '"',
+			}
+
+	# --- Build the return value
+	hToken = {
+		type: 'tag'
+		tagName
+		}
+
+	if subtype
+		hToken.subtype = subtype
+		hToken.orgtag = "#{tagName}:#{subtype}"
+	else
+		hToken.orgtag = tagName
+
+	# --- if tagName == 'svelte', set hToken.tagName to hToken.orgtag
+	if (tagName == 'svelte')
+		hToken.tagName = hToken.orgtag
+
+	if nonEmpty(hAttr)
+		hToken.hAttr = hAttr
+
+	# --- Is there contained text?
+	if rest
+		hToken.text = rest
+
+	return hToken
+
+# ---------------------------------------------------------------------------
+# --- export only for unit testing
+
+export attrStr = (hAttr) ->
+
+	if ! hAttr
+		return ''
+	str = ''
+	for attrName in Object.getOwnPropertyNames(hAttr)
+		{value, quote, shorthand} = hAttr[attrName]
+		if shorthand
+			str += " {#{value}}"
+		else
+			if quote == '{'
+				bquote = '{'
+				equote = '}'
+			else
+				bquote = equote = quote
+			str += " #{attrName}=#{bquote}#{value}#{equote}"
+	return str
+
+# ---------------------------------------------------------------------------
+
+export tag2str = (hToken, type='begin') ->
+
+	{tagName, hAttr} = hToken
+	if (type == 'begin')
+		str = "<#{tagName}"    # build the string bit by bit
+		if nonEmpty(hAttr)
+			str += attrStr(hAttr)
+		str += '>'
+		return str
+	else if (type == 'end')
+		if hNoEnd[tagName]
+			return undef
+		else
+			return "</#{tagName}>"
+	else
+		croak "type must be 'begin' or 'end'"
+
+# ---------------------------------------------------------------------------
+#    elem - indent text, surround with HTML tags
+
+export elem = (tagName, hAttr=undef, text=undef, oneIndent="\t") ->
+
+	if isEmpty(text)
+		return undef
+	hToken = {
+		tagName
+		hAttr
+		text
+		}
+	return arrayToBlock([
+		tag2str(hToken, 'begin')
+		indented(text, 1, oneIndent)
+		tag2str(hToken, 'end')
+		])

package/src/html_utils.js

@@ -0,0 +1,222 @@
+// Generated by CoffeeScript 2.7.0
+// html_utils.coffee
+var hNoEnd, i, len, ref, tagName;
+
+import {
+  assert,
+  croak
+} from '@jdeighan/unit-tester/utils';
+
+import {
+  undef,
+  pass,
+  words,
+  isEmpty,
+  nonEmpty
+} from '@jdeighan/coffee-utils';
+
+import {
+  indented,
+  enclose
+} from '@jdeighan/coffee-utils/indent';
+
+import {
+  arrayToBlock
+} from '@jdeighan/coffee-utils/block';
+
+import {
+  debug
+} from '@jdeighan/coffee-utils/debug';
+
+hNoEnd = {};
+
+ref = words('area base br col command embed hr img input' + ' keygen link meta param source track wbr');
+for (i = 0, len = ref.length; i < len; i++) {
+  tagName = ref[i];
+  hNoEnd[tagName] = true;
+}
+
+// ---------------------------------------------------------------------------
+export var parsetag = function(line) {
+  var _, all, attrName, br_val, className, dq_val, hAttr, hToken, ident, j, lClasses, lMatches, len1, modifiers, prefix, quote, ref1, rest, sq_val, subtype, uq_val, value, varName;
+  if (lMatches = line.match(/^(?:([A-Za-z][A-Za-z0-9_]*)\s*=\s*)?([A-Za-z][A-Za-z0-9_]*)(?:\:([a-z]+))?(\S*)\s*(.*)$/)) { // variable name
+    // variable is optional
+    // tag name
+    // modifiers (class names, etc.)
+    // attributes & enclosed text
+    [_, varName, tagName, subtype, modifiers, rest] = lMatches;
+  } else {
+    croak(`parsetag(): Invalid HTML: '${line}'`);
+  }
+  // --- Handle classes - subtypes and added via .<class>
+  lClasses = [];
+  if (nonEmpty(subtype) && (tagName !== 'svelte')) {
+    lClasses.push(subtype);
+  }
+  if (modifiers) {
+    // --- currently, these are only class names
+    while (lMatches = modifiers.match(/^\.([A-Za-z][A-Za-z0-9_]*)/)) {
+      [all, className] = lMatches;
+      lClasses.push(className);
+      modifiers = modifiers.substring(all.length);
+    }
+    if (modifiers) {
+      croak(`parsetag(): Invalid modifiers in '${line}'`);
+    }
+  }
+  // --- Handle attributes
+  hAttr = {}; // { name: { value: <value>, quote: <quote> }, ... }
+  if (varName) {
+    hAttr['bind:this'] = {
+      value: varName,
+      quote: '{'
+    };
+  }
+  if ((tagName === 'script') && (subtype === 'startup')) {
+    hAttr['context'] = {
+      value: 'module',
+      quote: '"'
+    };
+  }
+  if (rest) {
+    while (lMatches = rest.match(/^(?:(?:(?:(bind|on):)?([A-Za-z][A-Za-z0-9_]*))=(?:\{([^}]*)\}|"([^"]*)"|'([^']*)'|([^"'\s]+))|\{([A-Za-z][A-Za-z0-9_]*)\})\s*/)) { // prefix
+      // attribute name
+      // attribute value
+      [all, prefix, attrName, br_val, dq_val, sq_val, uq_val, ident] = lMatches;
+      if (ident) {
+        hAttr[ident] = {
+          value: ident,
+          shorthand: true
+        };
+      } else {
+        if (br_val) {
+          value = br_val;
+          quote = '{';
+        } else {
+          assert(prefix == null, "prefix requires use of {...}");
+          if (dq_val) {
+            value = dq_val;
+            quote = '"';
+          } else if (sq_val) {
+            value = sq_val;
+            quote = "'";
+          } else {
+            value = uq_val;
+            quote = '';
+          }
+        }
+        if (prefix) {
+          attrName = `${prefix}:${attrName}`;
+        }
+        if (attrName === 'class') {
+          ref1 = value.split(/\s+/);
+          for (j = 0, len1 = ref1.length; j < len1; j++) {
+            className = ref1[j];
+            lClasses.push(className);
+          }
+        } else {
+          if (hAttr.attrName != null) {
+            croak(`parsetag(): Multiple attributes named '${attrName}'`);
+          }
+          hAttr[attrName] = {value, quote};
+        }
+      }
+      rest = rest.substring(all.length);
+    }
+  }
+  // --- The rest is contained text
+  rest = rest.trim();
+  if (lMatches = rest.match(/^['"](.*)['"]$/)) {
+    rest = lMatches[1];
+  }
+  // --- Add class attribute to hAttr if there are classes
+  if (lClasses.length > 0) {
+    hAttr.class = {
+      value: lClasses.join(' '),
+      quote: '"'
+    };
+  }
+  // --- Build the return value
+  hToken = {
+    type: 'tag',
+    tagName
+  };
+  if (subtype) {
+    hToken.subtype = subtype;
+    hToken.orgtag = `${tagName}:${subtype}`;
+  } else {
+    hToken.orgtag = tagName;
+  }
+  // --- if tagName == 'svelte', set hToken.tagName to hToken.orgtag
+  if (tagName === 'svelte') {
+    hToken.tagName = hToken.orgtag;
+  }
+  if (nonEmpty(hAttr)) {
+    hToken.hAttr = hAttr;
+  }
+  // --- Is there contained text?
+  if (rest) {
+    hToken.text = rest;
+  }
+  return hToken;
+};
+
+// ---------------------------------------------------------------------------
+// --- export only for unit testing
+export var attrStr = function(hAttr) {
+  var attrName, bquote, equote, j, len1, quote, ref1, shorthand, str, value;
+  if (!hAttr) {
+    return '';
+  }
+  str = '';
+  ref1 = Object.getOwnPropertyNames(hAttr);
+  for (j = 0, len1 = ref1.length; j < len1; j++) {
+    attrName = ref1[j];
+    ({value, quote, shorthand} = hAttr[attrName]);
+    if (shorthand) {
+      str += ` {${value}}`;
+    } else {
+      if (quote === '{') {
+        bquote = '{';
+        equote = '}';
+      } else {
+        bquote = equote = quote;
+      }
+      str += ` ${attrName}=${bquote}${value}${equote}`;
+    }
+  }
+  return str;
+};
+
+// ---------------------------------------------------------------------------
+export var tag2str = function(hToken, type = 'begin') {
+  var hAttr, str;
+  ({tagName, hAttr} = hToken);
+  if (type === 'begin') {
+    str = `<${tagName}`;
+    if (nonEmpty(hAttr)) {
+      str += attrStr(hAttr);
+    }
+    str += '>';
+    return str;
+  } else if (type === 'end') {
+    if (hNoEnd[tagName]) {
+      return undef;
+    } else {
+      return `</${tagName}>`;
+    }
+  } else {
+    return croak("type must be 'begin' or 'end'");
+  }
+};
+
+// ---------------------------------------------------------------------------
+//    elem - indent text, surround with HTML tags
+export var elem = function(tagName, hAttr = undef, text = undef, oneIndent = "\t") {
+  var hToken;
+  if (isEmpty(text)) {
+    return undef;
+  }
+  hToken = {tagName, hAttr, text};
+  return arrayToBlock([tag2str(hToken, 'begin'), indented(text, 1, oneIndent), tag2str(hToken, 'end')]);
+};

package/src/indent_utils.coffee

@@ -164,14 +164,3 @@ export enclose = (text, pre, post, oneIndent="\t") ->
 		indented(text, 1, oneIndent)
 		post
 		])
-
-# ---------------------------------------------------------------------------
-#    elem - indent text, surround with HTML tags
-
-export elem = (text, tag, oneIndent="\t") ->
-
-	return arrayToBlock([
-		"<#{tag}>"
-		indented(text, 1, oneIndent)
-		"</#{tag}>"
-		])

package/src/indent_utils.js

@@ -187,9 +187,3 @@ export var untabify = function(str, numSpaces = 3) {
 export var enclose = function(text, pre, post, oneIndent = "\t") {
   return arrayToBlock([pre, indented(text, 1, oneIndent), post]);
 };
-
-// ---------------------------------------------------------------------------
-//    elem - indent text, surround with HTML tags
-export var elem = function(text, tag, oneIndent = "\t") {
-  return arrayToBlock([`<${tag}>`, indented(text, 1, oneIndent), `</${tag}>`]);
-};