book-source 0.2.2 → 0.2.4

package/lib/StructuredDocument.js

@@ -52,22 +52,59 @@ StructuredDocument.prototype.render = function( renderer ) {
 		title: this.title
 	} ;
 
-	var str = this.renderParts( renderer , this.parts , [] ) ;
+	var output = this.renderParts( renderer , this.parts , [] ) ;
 
 	if ( renderer.document ) {
-		str = renderer.document( meta , str ) ;
+		output = renderer.document( meta , output ) ;
 	}
 
-	return str ;
+	return output ;
+} ;
+
+
+
+const FRAGMENT = {} ;
+
+FRAGMENT.string = {
+	new: () => '' ,
+	append: ( stack_ , part ) => stack_ + ( part || '' ) ,
+	concat: ( stack_ , parts ) => stack_ + ( parts || '' )
 } ;
 
+FRAGMENT.flatStructure = {
+	new: () => [] ,
+	append: ( stack_ , part ) => {
+		if ( part ) {
+			if ( Array.isArray( part ) ) { stack_.push( ... part ) ; }
+			else { stack_.push( part ) ; }
+		}
+		return stack_ ;
+	} ,
+	concat: ( stack_ , parts ) => {
+		if ( parts && parts.length ) { stack_.push( ... parts ) ; }
+		return stack_ ;
+	}
+} ;
 
+FRAGMENT.structure = {
+	new: () => [] ,
+	append: ( stack_ , part ) => {
+		if ( part ) { stack_.push( part ) ; }
+		return stack_ ;
+	} ,
+	concat: ( stack_ , parts ) => {
+		if ( parts && parts.length ) { stack_.push( ... parts ) ; }
+		return stack_ ;
+	}
+} ;
 
 StructuredDocument.prototype.renderParts = function( renderer , parts , partStack ) {
-	var str = '' , index = 0 ;
+	var fragment = FRAGMENT[ renderer.type || 'string' ] ,
+		output = fragment.new() ,
+		index = 0 ;
 
 	for ( let part of parts ) {
-		let partsStr = '' ;
+		let partsOutput = fragment.new() ;
 
 		if ( part.parts ) {
 			if ( renderer.group?.[ part.type ] ) {
@@ -79,27 +116,36 @@ StructuredDocument.prototype.renderParts = function( renderer , parts , partStac
 				for ( let group of groupList ) {
 					if ( renderer.group[ part.type ][ group.type ] ) {
 						partStack.push( part ) ;
-						let groupStr = this.renderParts( renderer , group.parts , partStack ) ;
+						let groupOutput = this.renderParts( renderer , group.parts , partStack ) ;
 						partStack.pop() ;
-						partsStr += renderer.group[ part.type ][ group.type ]( part , groupStr , partStack ) ;
+						partsOutput = fragment.concat(
+							partsOutput ,
+							renderer.group[ part.type ][ group.type ]( part , groupOutput , partStack )
+						) ;
 					}
 				}
 			}
 			else {
 				partStack.push( part ) ;
-				partsStr = this.renderParts( renderer , part.parts , [ ... partStack , part ] ) ;
+				partsOutput = fragment.concat(
+					partsOutput ,
+					this.renderParts( renderer , part.parts , [ ... partStack , part ] )
+				) ;
 				partStack.pop() ;
 			}
 		}
 
 		if ( renderer[ part.type ] ) {
-			str += renderer[ part.type ]( part , partsStr , partStack , index ) ;
+			output = fragment.append(
+				output ,
+				renderer[ part.type ]( part , partsOutput , partStack , index )
+			) ;
 		}
 
 		index ++ ;
 	}
 
-	return str ;
+	return output ;
 } ;
 
 
@@ -629,12 +675,13 @@ function parseOrderedListItem( str , ctx , indent ) {
 	var lastPart = ctx.parts[ ctx.parts.length - 1 ] ;
 
 	if ( ! lastPart || lastPart.type !== 'orderedList' ) {
-		ctx.parts.push( new documentParts.OrderedList( indent ) ) ;
+		lastPart = new documentParts.OrderedList( indent ) ;
+		ctx.parts.push( lastPart ) ;
 	}
 
 	stack( ctx ) ;
 
-	ctx.parts.push( new documentParts.OrderedListItem( indent , order ) ) ;
+	ctx.parts.push( new documentParts.OrderedListItem( indent , order , lastPart.autoIndex ++ ) ) ;
 
 	var blockEnd = detectBlockEnd( str , ctx.i , ctx.parent?.indent , LIST_ITEM_END_PARAMS ) ;
 	parseInlineChildren( str , ctx , blockEnd ) ;

package/lib/documentParts.js

@@ -247,6 +247,7 @@ documentParts.ListItem = ListItem ;
 function OrderedList( indent ) {
 	this.type = 'orderedList' ;
 	this.indent = indent ;
+	this.autoIndex = 1 ;
 	BlockPart.call( this ) ;
 }
 
@@ -256,10 +257,11 @@ documentParts.OrderedList = OrderedList ;
 
 
 
-function OrderedListItem( indent , order ) {
+function OrderedListItem( indent , order , index ) {
 	this.type = 'orderedListItem' ;
 	this.indent = indent ;
-	this.order = order ;
+	this.order = order ;	// User order value
+	this.index = index ;	// Real index, starting at 1, and auto-incrementing
 	BlockPart.call( this ) ;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "book-source",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "A lightweight markup language, inspired by Markdown.",
   "main": "lib/book-source.js",
   "directories": {