book-source 0.3.11 → 0.3.13

package/lib/StructuredDocument.js

@@ -30,7 +30,6 @@
 
 const documentParts = require( './documentParts.js' ) ;
 const Style = require( './Style.js' ) ;
-const Theme = require( './Theme.js' ) ;
 const textPostFilters = require( './textPostFilters.js' ) ;
 
 const inPlaceFilter = require( 'array-kit/lib/inPlaceFilter.js' ) ;
@@ -38,24 +37,41 @@ const inPlaceFilter = require( 'array-kit/lib/inPlaceFilter.js' ) ;
 
 
 function StructuredDocument() {
+	this.type = 'document' ;
 	this.title = 'Document' ;
 	this.metadata = null ;
 	this.theme = null ;
+	this.summary = null ;
 	this.parts = [] ;
+	//this.idList = new Set() ;
 }
 
 module.exports = StructuredDocument ;
 
+// Circular require, should come after exporting
+const postProcesses = require( './postProcesses.js' ) ;
 
 
-StructuredDocument.prototype.render = function( renderer ) {
-	var meta = {
-		title: this.title
-	} ;
 
-	var output = this.renderParts( renderer , this.parts , [] , [ {} ] ) ;
+StructuredDocument.prototype.render = function( renderer , special = null ) {
+	let toRender ;
+
+	switch ( special ) {
+		case 'summary' :
+			toRender = this.summary ? [ this.summary ] : [] ;
+			break ;
+		default :
+			toRender = this.parts ;
+			break ;
+	}
+
+	let output = this.renderParts( renderer , toRender , [] , [ {} ] ) ;
 
 	if ( renderer.document ) {
+		let meta = {
+			title: this.title
+		} ;
+
 		output = renderer.document( meta , output ) ;
 	}
 
@@ -199,25 +215,79 @@ StructuredDocument.prototype.autoTitle = function() {
 
 	if ( ! header ) { return ; }
 
-	str = StructuredDocument.getText( header.parts ) ;
+	str = StructuredDocument.getText( header ) ;
 	if ( str ) { this.title = str ; }
 } ;
 
 
 
-StructuredDocument.getText = function( parts ) {
-	var str = '' ;
+StructuredDocument.prototype.postProcess = function( params = {} ) {
+	var data = {} ,
+		postProcessArray = [] ,
+		postProcessMap = new Map() ;
 
-	for ( let part of parts ) {
-		if ( part.text ) { str += part.text ; }
-		else if ( part.parts?.length ) { str += StructuredDocument.getText( part.parts ) ; }
+	for ( let postProcessName of Object.keys( params ) ) {
+		if ( ! postProcesses[ postProcessName ] || ! params[ postProcessName ] ) { continue ; }
+
+		let postProcess = postProcesses[ postProcessName ] ;
+
+		// Add required post-process first
+		if ( postProcess.require ) {
+			for ( let requiredName of postProcess.require ) {
+				if ( ! postProcessMap.has( requiredName ) ) {
+					let entry = { name: requiredName , params: {} } ;
+					postProcessArray.push( entry ) ;
+					postProcessMap.set( requiredName , entry ) ;
+				}
+			}
+		}
+
+		if ( postProcessMap.has( postProcessName ) ) {
+			// It was already added by a dependency, just patch the params if needed
+			if ( typeof params[ postProcessName ] === 'object' ) {
+				let entry = postProcessMap.get( postProcessName ) ;
+				entry.params = Object.assign( {} , params[ postProcessName ] ) ;
+			}
+		}
+		else {
+			let entry = {
+				name: postProcessName ,
+				params: typeof params[ postProcessName ] === 'object' ? Object.assign( {} , params[ postProcessName ] ) : {}
+			} ;
+
+			postProcessArray.push( entry ) ;
+			postProcessMap.set( postProcessName , entry ) ;
+		}
 	}
 
-	return str ;
+	for ( let entry of postProcessArray ) {
+		if ( postProcesses[ entry.name ].init ) {
+			postProcesses[ entry.name ].init( this , entry.params , data ) ;
+		}
+	}
+
+	this.postProcessRecursive( this , postProcessArray , data ) ;
+
+	for ( let entry of postProcessArray ) {
+		if ( postProcesses[ entry.name ].finalize ) {
+			postProcesses[ entry.name ].finalize( this , entry.params , data ) ;
+		}
+	}
 } ;
 
-// Backqard compatibility/API
-StructuredDocument.prototype.getText = function( parts = this.parts ) { return StructuredDocument.getText( parts ) ; } ;
+
+
+StructuredDocument.prototype.postProcessRecursive = function( object , postProcessArray , data ) {
+	for ( let entry of postProcessArray ) {
+		postProcesses[ entry.name ]( this , object , entry.params , data ) ;
+	}
+
+	if ( object.parts && object.parts.length ) {
+		for ( let part of object.parts ) {
+			this.postProcessRecursive( part , postProcessArray , data ) ;
+		}
+	}
+} ;
 
 
 
@@ -251,10 +321,49 @@ StructuredDocument.prototype.oneTextPostFilter = function( postFilter , parts ,
 
 
 
+// Utility methods
+
+
+
+StructuredDocument.getText = function( object ) {
+	if ( Array.isArray( object ) ) {
+		object = { parts: object } ;
+	}
+
+	if ( object.text ) { return object.text ; }
+	if ( ! object.parts || ! object.parts.length ) { return '' ; }
+
+	let str = '' ;
+
+	for ( let part of object.parts ) {
+		str += StructuredDocument.getText( part ) ;
+	}
+
+	return str ;
+} ;
+
+// Backward compatibility/API
+StructuredDocument.prototype.getText = function( object = this ) { return StructuredDocument.getText( object ) ; } ;
+
+
+
+StructuredDocument.textToId = function( text ) {
+	return text
+		.trim()
+		.normalize( 'NFC' )
+		.replace( /[\s]+/g , '_' )
+		.replace( /[^\p{L}\p{N}_.:-]/gu , '' )
+		.replace( /_+/g , '_' ) ;
+} ;
+
+
+
 // Parser
 
-StructuredDocument.parse = function( str , options ) {
-	if ( ! options || typeof options !== 'object' ) { options = {} ; }
+
+
+StructuredDocument.parse = function( str , params ) {
+	if ( ! params || typeof params !== 'object' ) { params = {} ; }
 
 	if ( typeof str !== 'string' ) {
 		if ( str && typeof str === 'object' ) { str = str.toString() ; }
@@ -281,10 +390,11 @@ StructuredDocument.parse = function( str , options ) {
 	parseBlocks( str , ctx ) ;
 
 	for ( let table of ctx.rowSpanTables ) { postProcessTableRowSpan( table ) ; }
+
 	ctx.structuredDocument.autoTitle() ;
 
 	if ( ctx.rawMetadata ) {
-		let metadataParser = options.metadataParser || JSON.parse ;
+		let metadataParser = params.metadataParser || JSON.parse ;
 		for ( let type in ctx.rawMetadata ) {
 			try {
 				let parsed = metadataParser( ctx.rawMetadata[ type ] ) ;
@@ -387,6 +497,9 @@ function parseBlock( str , ctx ) {
 		case BLOCK_METADATA :
 			parseMetadata( str , ctx ) ;
 			break ;
+		case BLOCK_SPECIAL :
+			parseSpecial( str , ctx ) ;
+			break ;
 		default :
 			throw new Error( "Bad block detection: " + blockType ) ;
 	}
@@ -495,6 +608,7 @@ const BLOCK_TABLE_ROW_THICK_SEPARATOR = 42 ;
 const BLOCK_TABLE_CAPTION = 43 ;
 const BLOCK_ANCHOR = 50 ;
 const BLOCK_METADATA = 60 ;
+const BLOCK_SPECIAL = 80 ;
 
 function detectBlockType( str , i ) {
 	if ( str[ i ] === '\\' ) {
@@ -502,14 +616,17 @@ function detectBlockType( str , i ) {
 	}
 
 	if ( str[ i ] === '#' ) {
-		if ( str[ i + 1 ] === '(' ) { return BLOCK_ANCHOR ; }
+		if ( str[ i + 1 ] === '(' ) {
+			if ( str[ i + 2 ] === '%' ) { return BLOCK_SPECIAL ; }
+			return BLOCK_ANCHOR ;
+		}
 		return BLOCK_HEADER ;
 	}
 
 	if ( str[ i ] === '!' && str[ i + 2 ] === '[' ) {
 		if ( str[ i + 1 ] === '=' ) { return BLOCK_MEDIA ; }
-		else if ( str[ i + 1 ] === '<' ) { return BLOCK_FLOAT_LEFT_MEDIA ; }
-		else if ( str[ i + 1 ] === '>' ) { return BLOCK_FLOAT_RIGHT_MEDIA ; }
+		if ( str[ i + 1 ] === '<' ) { return BLOCK_FLOAT_LEFT_MEDIA ; }
+		if ( str[ i + 1 ] === '>' ) { return BLOCK_FLOAT_RIGHT_MEDIA ; }
 		return BLOCK_PARAGRAPH ;
 	}
 
@@ -860,6 +977,18 @@ function parseAnchor( str , ctx ) {
 
 
 
+function parseSpecial( str , ctx ) {
+	//console.log( "parseSpecial()" ) ;
+	var end = searchCloser( str , ctx.i + 3 , '(' , ')' , true ) ;
+	if ( end < 0 ) { return parseParagraph( str , ctx ) ; }
+
+	ctx.parts.push( new documentParts.Special( str.slice( ctx.i + 3 , end ) ) ) ;
+
+	ctx.i = end + 1 ;
+}
+
+
+
 function parseTableCaption( str , ctx ) {
 	//console.log( "parseTableCaption()" ) ;
 	var lastCharOfLine = searchLastCharOfLine( str , ctx.i + 1 ) ;
@@ -1369,9 +1498,7 @@ function parseInlineChildrenOfParent( str , ctx , parent , blockEnd , trim = fal
 // Try to parse non-block content
 function parseInline( str , ctx , blockEnd , trim = false ) {
 	//console.log( "parseInline() -- remaining:" , ctx.i , str.slice( ctx.i ) ) ;
-	var isSpace , scanEnd ;
-
-	scanEnd = blockEnd = blockEnd ?? searchEndOfLine( str , ctx.i ) ;
+	var scanEnd = blockEnd = blockEnd ?? searchEndOfLine( str , ctx.i ) ;
 
 	if ( trim ) {
 		let first = searchNextNotInSet( str , ctx.i , blockEnd , WHITE_SPACES ) ;
@@ -1657,7 +1784,7 @@ function parseInfotipedText( str , ctx , scanEnd ) {
 	ctx.iStartOfInlineChunk = ctx.i + 1 ;
 
 	if ( ! href && ! hint ) {
-		infotipedText.href = StructuredDocument.getText( infotipedText.parts ) ;
+		infotipedText.href = StructuredDocument.getText( infotipedText ) ;
 	}
 }
 
@@ -2011,7 +2138,7 @@ function searchBlockSwitchCloser( str , i , closer , closerMinStreak = 1 , end =
 	Same that searchBlockSwitchCloser() but with a callback function.
 */
 function searchFixedBlockSwitchCloser( str , i , fixed , end = str.length ) {
-	var test , j , failed ;
+	var j , failed ;
 
 	while ( i < end ) {
 		// Search next line

package/lib/documentParts.js

@@ -33,13 +33,17 @@ module.exports = documentParts ;
 
 
 
-function Part() {}
+function Part() {
+	this.id = null ;
+}
 
 documentParts.Part = Part ;
 
 
 
-function InlinePart() {}
+function InlinePart() {
+	Part.call( this ) ;
+}
 
 InlinePart.prototype = Object.create( Part.prototype ) ;
 InlinePart.prototype.constructor = InlinePart ;
@@ -48,6 +52,7 @@ documentParts.InlinePart = InlinePart ;
 
 
 function InlineContainerPart() {
+	Part.call( this ) ;
 	this.parts = [] ;
 }
 
@@ -58,6 +63,7 @@ documentParts.InlineContainerPart = InlineContainerPart ;
 
 
 function InlineTextPart( text ) {
+	Part.call( this ) ;
 	this.text = text ;
 }
 
@@ -67,7 +73,9 @@ documentParts.InlineTextPart = InlineTextPart ;
 
 
 
-function BlockPart() {}
+function BlockPart() {
+	Part.call( this ) ;
+}
 
 BlockPart.prototype = Object.create( Part.prototype ) ;
 BlockPart.prototype.constructor = BlockPart ;
@@ -76,6 +84,7 @@ documentParts.BlockPart = BlockPart ;
 
 
 function BlockContainerPart() {
+	Part.call( this ) ;
 	this.parts = [] ;
 }
 
@@ -362,6 +371,18 @@ documentParts.Anchor = Anchor ;
 
 
 
+function Special( special ) {
+	this.type = 'special' ;
+	this.special = special ;
+	BlockContainerPart.call( this ) ;
+}
+
+Special.prototype = Object.create( BlockContainerPart.prototype ) ;
+Special.prototype.constructor = Special ;
+documentParts.Special = Special ;
+
+
+
 function ImageBlock( href , altText , float , caption , hint ) {
 	this.type = 'imageBlock' ;
 	this.href = href ;

package/lib/postProcesses.js

@@ -0,0 +1,150 @@
+/*
+	Book Source
+
+	Copyright (c) 2023 Cédric Ronvel
+
+	The MIT License (MIT)
+
+	Permission is hereby granted, free of charge, to any person obtaining a copy
+	of this software and associated documentation files (the "Software"), to deal
+	in the Software without restriction, including without limitation the rights
+	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+	copies of the Software, and to permit persons to whom the Software is
+	furnished to do so, subject to the following conditions:
+
+	The above copyright notice and this permission notice shall be included in all
+	copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+	SOFTWARE.
+*/
+
+"use strict" ;
+
+
+
+const StructuredDocument = require( './StructuredDocument.js' ) ;
+const documentParts = require( './documentParts.js' ) ;
+
+
+
+exports.autoId = ( structuredDocument , object , params , data ) => {
+	if ( ! params.types.has( object.type ) ) { return ; }
+
+	let text = StructuredDocument.getText( object ) ;
+	let id = data.idPrefix + StructuredDocument.textToId( text ) ;
+
+	if ( data.idList.has( id ) ) {
+		let originalId = id ;
+		let count = data.idList.get( originalId ) ;
+		count ++ ;
+		id = originalId + '_' + count ;
+
+		while ( data.idList.has( id ) ) {
+			count ++ ;
+			id = originalId + '_' + count ;
+		}
+
+		data.idList.set( originalId , count ) ;
+	}
+
+	// Always add the current ID, even if originalId was added too
+	data.idList.set( id , 1 ) ;
+
+	object.id = id ;
+} ;
+
+const DEFAULT_AUTO_ID_TYPES = new Set( [ 'header' ] ) ;
+
+exports.autoId.init = ( structuredDocument , params , data ) => {
+	if ( Array.isArray( params.types ) ) { params.types = new Set( params.types ) ; }
+	else if ( ! params.types || ! ( params.types instanceof Set ) ) { params.types = DEFAULT_AUTO_ID_TYPES ; }
+
+	if ( data.idPrefix === undefined ) { data.idPrefix = params.idPrefix || '' ; }
+
+	data.idList = new Map() ;
+} ;
+
+
+
+exports.summary = ( structuredDocument , object , params , data ) => {
+	if ( object.type === 'special' ) {
+		switch ( object.special ) {
+			case 'summary' :
+				data.summaryObjects.push( object ) ;
+				break ;
+			case 'summary-start' :
+				resetSummary( data ) ;
+				break ;
+			case 'summary-end' :
+				data.summaryEnded = true ;
+				break ;
+		}
+
+		return ;
+	}
+
+	if ( data.summaryEnded || object.type !== 'header' || object.level > params.maxLevel ) { return ; }
+
+	let item = new documentParts.ListItem( object.level - 1 ) ;
+	let link = new documentParts.Link( '#' + object.id ) ;
+	item.parts.push( link ) ;
+	let text = new documentParts.Text( StructuredDocument.getText( object ) ) ;
+	link.parts.push( text ) ;
+
+	if ( ! data.summaryHeaderLevelStack.length ) {
+		data.summaryHeaderLevelStack.push( object.level ) ;
+	}
+
+	let lastListLevel = data.summaryHeaderLevelStack.length - 1 ;
+	let lastHeaderLevel = data.summaryHeaderLevelStack[ lastListLevel ] ;
+
+	while ( object.level < lastHeaderLevel && lastListLevel > 0 ) {
+		lastListLevel -- ;
+		lastHeaderLevel = data.summaryHeaderLevelStack[ lastListLevel ] ;
+		data.summaryHeaderLevelStack.length = data.summaryListStack.length = lastListLevel + 1 ;
+	}
+
+	if ( object.level > lastHeaderLevel ) {
+		let parentList = data.summaryListStack[ lastListLevel ] ;
+		let currentList = new documentParts.List( object.level - 1 ) ;
+		data.summaryListStack.push( currentList ) ;
+		data.summaryHeaderLevelStack.push( object.level ) ;
+		currentList.parts.push( item ) ;
+		parentList.parts.push( currentList ) ;
+	}
+	else {
+		// It's equal OR the doc is not well-formed and it's less, nevertheless, we just act as if it's equal
+		let currentList = data.summaryListStack[ lastListLevel ] ;
+		currentList.parts.push( item ) ;
+	}
+} ;
+
+exports.summary.init = ( structuredDocument , params , data ) => {
+	params.maxLevel = params.maxLevel || Infinity ;
+	data.summaryObjects = [] ;
+	resetSummary( data ) ;
+} ;
+
+function resetSummary( data ) {
+	data.summaryList = new documentParts.List( 0 ) ;
+	data.summaryListStack = [ data.summaryList ] ;
+	data.summaryHeaderLevelStack = [] ;
+	data.summaryEnded = false ;
+}
+
+exports.summary.finalize = ( structuredDocument , params , data ) => {
+	structuredDocument.summary = data.summaryList ;
+
+	for ( let summaryObject of data.summaryObjects ) {
+		summaryObject.parts.push( data.summaryList ) ;
+	}
+} ;
+
+exports.summary.require = [ 'autoId' ] ;
+

package/package.json

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