pict-section-recordset 1.0.15 → 1.0.18

package/source/providers/RecordSet-RecordProvider-MeadowEndpoints.js

@@ -10,7 +10,7 @@ const libRecordSetProviderBase = require('./RecordSet-RecordProvider-Base.js');
  * Class representing a data change detection provider for Pict dynamic forms.
  * @extends libRecordSetProviderBase
  */
-class RecordSetProvider extends libRecordSetProviderBase
+class MeadowEndpointsRecordSetProvider extends libRecordSetProviderBase
 {
 	/**
 	 * Creates an instance of RecordSetProvider.
@@ -26,8 +26,21 @@ class RecordSetProvider extends libRecordSetProviderBase
 		this.options;
 		/** @type {import('fable')} */
 		this.fable;
-		/** @type {import('fable') & import('pict')} */
+		/** @type {import('pict') & {
+		 *      log: any,
+		 *      services:
+		 *      {
+		 *			PictSectionRecordSet: InstanceType<import('../Pict-Section-RecordSet.js')>,
+		 *			[key: string]: any,
+		 *		},
+		 *      instantiateServiceProviderWithoutRegistration: (hash: String) => any,
+		 *      PictSectionRecordSet: InstanceType<import('../Pict-Section-RecordSet.js')>
+		 *  }} */
 		this.pict;
+		/** @type {string} */
+		this.Hash;
+		/** @type {string} */
+		this.UUID;
 		//TODO: make this typedef better
 		/** @type {Record<string, any>} */
 		this._Schema = { };
@@ -359,6 +372,43 @@ class RecordSetProvider extends libRecordSetProviderBase
 		}
 		return this._Schema;
 	}
+
+	/**
+	 * Abstract decoration method for core records. Subclasses should implement this method to decorate records with additional information.
+	 *
+	 * @param {Array<Record<string, any>>} pRecords - The records to decorate.
+	 * @return {Promise<void>}
+	 */
+	async decorateCoreRecords(pRecords)
+	{
+		if (!this.options.RecordDecorationConfiguration)
+		{
+			return;
+		}
+		if (!Array.isArray(this.options.RecordDecorationConfiguration))
+		{
+			this.pict.log.error('RecordDecorationConfiguration is not an array', { RecordDecorationConfiguration: this.options.RecordDecorationConfiguration });
+			return;
+		}
+		this.pict.AppData[this.Hash] = { CoreEntityRecordSubset: pRecords };
+		const config = [{ Type: 'SetStateAddress', StateAddress: `AppData[${this.Hash}]` }].concat(this.options.RecordDecorationConfiguration);
+
+		try
+		{
+			await new Promise((resolve, reject) => this.pict.EntityProvider.gatherDataFromServer(config, (err) =>
+			{
+				if (err)
+				{
+					return reject(err);
+				}
+				resolve();
+			}));
+		}
+		catch (error)
+		{
+			this.pict.log.error(`MeadowEndpointsRecordSetProvider: Error gathering data from server for record decoration: ${error.message}`, { Stack: error.stack });
+		}
+	}
 }
 
-module.exports = RecordSetProvider;
+module.exports = MeadowEndpointsRecordSetProvider;

package/source/providers/RecordSet-Router.js

@@ -40,6 +40,8 @@ class PictRecordSetRouter extends libPictProvider
 
 	addRoutes(pRouter)
 	{
+		//FIXME: not working
+		this.pictRouter.addRoute('/PSRS/404', '{~D:Pict.views[RSP-RecordSet-Error-NotFound].render()~}');
 		// TODO: Create some kind of state tracking to see if these routes have already been added
 		//this.pictRouter.addRoute('/PSRS/:RecordSet/List/:Begin/:Cap', "{~LV:Record~}");
 		this.pict.views['RSP-RecordSet-List'].addRoutes(pRouter);

package/source/services/RecordsSet-MetaController.js

@@ -1,5 +1,6 @@
 const libFableServiceProviderBase = require('fable-serviceproviderbase');
 
+const viewDefinitionRecordSetErrorNotFound = require('../views/error/RecordSet-Error-NotFound.json');
 const viewRecordSetList = require('../views/list/RecordSet-List.js');
 const viewRecordSetEdit = require('../views/edit/RecordSet-Edit.js');
 const viewRecordSetRead = require('../views/read/RecordSet-Read.js');
@@ -26,8 +27,9 @@ class RecordSetMetacontroller extends libFableServiceProviderBase
 		let tmpOptions = Object.assign({}, _DEFAULT_CONFIGURATION, pOptions);
 		super(pFable, tmpOptions, pServiceHash);
 
-		/** @type {import('pict') & { addAndInstantiateSingletonService: (hash: string, options: any, prototype: any) => any }} */
+		/** @type {import('pict') & { addAndInstantiateSingletonService: (hash: string, options: any, prototype: any) => any, newManyfest: (rec: any) => any }} */
 		this.fable;
+		this.pict = this.fable;
 		/** @type {any} */
 		this.log;
 		/** @type {any} */
@@ -45,9 +47,13 @@ class RecordSetMetacontroller extends libFableServiceProviderBase
 		this.recordSetProviders = {};
 		this.recordSetProviderConfigurations = {};
 
-		this.recordSetListConfigurations = {};
+		this.dashboardConfigurations = {};
+
 		this.sessionProviders = [];
 
+		this.manifestDefinitions = {};
+		this.manifests = { Default: this.pict.manifest };
+
 		this.has_initialized = false;
 	}
 
@@ -77,6 +83,15 @@ class RecordSetMetacontroller extends libFableServiceProviderBase
 				}
 			]
 	 */
+
+	/**
+	 * @return {Record<string, any>} - The registered configuration for the RecordSet
+	 */
+	getRecordSetConfiguration(pRecordSet)
+	{
+		return this.recordSetProviderConfigurations[pRecordSet];
+	}
+
 	loadRecordSetConfiguration(pRecordSetConfiguration)
 	{
 		if (typeof pRecordSetConfiguration !== 'object')
@@ -284,6 +299,8 @@ class RecordSetMetacontroller extends libFableServiceProviderBase
 		this.fable.addProvider('RecordSetLinkManager', {}, providerLinkManager);
 
 		// Add the subviews internally and externally
+		this.pict.addTemplate(require('../templates/Pict-Template-FilterView.js'));
+		this.childViews.errorNotFound = this.fable.addView('RSP-RecordSet-Error-NotFound', viewDefinitionRecordSetErrorNotFound);
 		this.childViews.list = this.fable.addView('RSP-RecordSet-List', this.options, viewRecordSetList);
 		this.childViews.edit = this.fable.addView('RSP-RecordSet-Edit', this.options, viewRecordSetEdit);
 		this.childViews.read = this.fable.addView('RSP-RecordSet-Read', this.options, viewRecordSetRead);
@@ -302,6 +319,22 @@ class RecordSetMetacontroller extends libFableServiceProviderBase
 			this.loadRecordSetConfigurationArray(this.fable.settings.DefaultRecordSetConfigurations);
 		}
 
+		for (const [ tmpManifestKey, tmpManifest ] of Object.entries(this.fable.settings.Manifests || {}))
+		{
+			if (!tmpManifest || !tmpManifest.Scope || !tmpManifest.Descriptors)
+			{
+				this.pict.log.error(`RecordSetDashboard: Invalid manifest: ${tmpManifestKey}.`, tmpManifest);
+				continue;
+			}
+			if (tmpManifestKey !== tmpManifest.Scope)
+			{
+				this.pict.log.error(`RecordSetDashboard: Manifest key ${tmpManifestKey} does not match manifest scope ${tmpManifest.Scope}.  This is bad.  Fix it.`);
+			}
+			this.generateManifestTableCells(tmpManifest);
+			this.manifestDefinitions[tmpManifest.Scope] = tmpManifest;
+			this.manifests[tmpManifest.Scope] = this.pict.newManyfest(tmpManifest);
+		}
+
 		this.has_initialized = true;
 
 		// Load pict-router if it isn't loaded
@@ -313,6 +346,55 @@ class RecordSetMetacontroller extends libFableServiceProviderBase
 
 		return true;
 	}
+
+	getManifest(pScope)
+	{
+		return this.manifests[pScope];
+	}
+
+	/**
+	 * @param {Record<string, any>} pManifest - The manifest to generate table cells for.
+	 */
+	generateManifestTableCells(pManifest)
+	{
+		if (!pManifest || !pManifest.Descriptors || !pManifest.Scope)
+		{
+			this.pict.log.error(`RecordSetDashboard: No manifest or descriptors found for ${pManifest}.  Cannot generate table cells.`);
+			if (pManifest)
+			{
+				pManifest.TableCells = [];
+			}
+			return;
+		}
+		const tmpTableCells = Object.entries(pManifest.Descriptors || {}).filter(([ key, descriptor ]) => descriptor.PictDashboard).map(([ key, descriptor ]) =>
+		{
+			const tmpPictDashboard = descriptor.PictDashboard;
+			if (tmpPictDashboard?.Equation && !tmpPictDashboard.ValueTemplate)
+			{
+				//FIXME: is this the right mapping?
+				if (tmpPictDashboard.EquationNamespaceScope === 'Full')
+				{
+					tmpPictDashboard.ValueTemplate = '{~SBR:Record.Data.PictDashboard.Equation::Pict.PictSectionRecordSet.getManifest(Record.Data.ManifestHash)~}';
+				}
+				else
+				{
+					tmpPictDashboard.ValueTemplate = '{~SBR:Record.Data.PictDashboard.Equation:Record.Payload:Pict.PictSectionRecordSet.getManifest(Record.Data.ManifestHash)~}';
+				}
+			}
+			if (!tmpPictDashboard.ValueTemplate)
+			{
+				tmpPictDashboard.ValueTemplate = '{~DVBK:Record.Payload:Record.Data.Key~}';
+			}
+			return {
+				Key: key,
+				DisplayName: descriptor.Name || key,
+				ManifestHash: pManifest.Scope,
+				PictDashboard: tmpPictDashboard,
+			};
+		});
+		pManifest.TableCells = tmpTableCells;
+	}
+
 }
 
 module.exports = RecordSetMetacontroller;

package/source/templates/Pict-Template-FilterView.js

@@ -0,0 +1,172 @@
+const libPictTemplate = require('pict-template');
+
+/**
+ * Specialized instruction for rendering the filter view and plumbing in required context.
+ *
+ * Based on the Pict base {~V:...~} template instruction.
+ */
+class PictTemplateFilterViewInstruction extends libPictTemplate
+{
+	/**
+	 * @param {Object} pFable - The Fable Framework instance
+	 * @param {Object} pOptions - The options for the service
+	 * @param {String} pServiceHash - The hash of the service
+	 */
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		/** @type {any} */
+		this.log;
+
+		this.addPattern('{~FV:', '~}');
+		this.addPattern('{~FilterView:', '~}');
+
+
+		if (!('__TemplateOutputCache' in this.pict))
+		{
+			this.pict.__TemplateOutputCache = {};
+		}
+	}
+
+	/**
+	 * Render a template expression, returning a string with the resulting content.
+	 *
+	 * @param {string} pTemplateHash - The hash contents of the template (what's between the template start and stop tags)
+	 * @param {any} pRecord - The json object to be used as the Record for the template render
+	 * @param {Array<any>} pContextArray - An array of context objects accessible from the template; safe to leave empty
+	 *
+	 * @return {string} The rendered template
+	 */
+	render(pTemplateHash, pRecord, pContextArray)
+	{
+		let [ tmpViewHash, tmpViewContext ] = pTemplateHash.split(':');
+		tmpViewHash = tmpViewHash.trim();
+		const tmpRecordSet = pRecord.RecordSet || '';
+		if (!tmpRecordSet)
+		{
+			this.pict.log.error(`Pict: Filter View Template Render: No record set specified in template hash [${pTemplateHash}] for view [${tmpViewHash}]`);
+			return '';
+		}
+		const tmpRecordSetConfiguration = this.pict.PictSectionRecordSet.recordSetProviderConfigurations?.[tmpRecordSet];
+		if (!tmpRecordSetConfiguration)
+		{
+			this.pict.log.error(`Pict: Filter View Template Render: No record set configuration found for [${tmpRecordSet}] in template hash [${pTemplateHash}] for view [${tmpViewHash}]`);
+			return '';
+		}
+		if (tmpViewContext)
+		{
+			tmpViewContext = tmpViewContext.trim();
+		}
+		else
+		{
+			tmpViewContext = 'Default';
+		}
+		if (!(tmpViewHash in this.pict.views))
+		{
+			this.log.warn(`Pict: Filter View Template Render: View not found for [${tmpViewHash}]`);
+			return '';
+		}
+
+		pRecord = pRecord || {};
+		if (!pRecord.RecordSet)
+		{
+			pRecord.RecordSet = tmpRecordSet;
+		}
+		if (!pRecord.RecordSetConfiguration)
+		{
+			pRecord.RecordSetConfiguration = tmpRecordSetConfiguration;
+		}
+		if (!pRecord.ViewContext)
+		{
+			pRecord.ViewContext = pRecord.DashboardHash ? `${tmpViewContext}-${pRecord.DashboardHash}` : tmpViewContext;
+		}
+
+		let tmpRenderGUID = this.pict.getUUID();
+
+		/** @type {import('pict-view')} */
+		const tmpView = this.pict.views[tmpViewHash];
+
+		tmpView.render('__Virtual', `__TemplateOutputCache.${tmpRenderGUID}`, pRecord);
+
+		let tmpResult = this.pict.__TemplateOutputCache[tmpRenderGUID];
+		// TODO: Uncomment this when we like how it's working
+		//delete this.pict.__TemplateOutputCache[tmpRenderGUID];
+
+		return tmpResult;
+	}
+
+	/**
+	 * @param {string} pTemplateHash - The hash contents of the template (what's between the template start and stop tags)
+	 * @param {any} pRecord - The json object to be used as the Record for the template
+	 * @param {(pError?: Error, pResult?: string) => void} fCallback - The callback function to call with the result
+	 * @param {Array<any>} pContextArray - An array of context objects accessible from the template; safe to leave empty
+	 * @return {void}
+	 */
+	renderAsync(pTemplateHash, pRecord, fCallback, pContextArray)
+	{
+		let [ tmpViewHash, tmpViewContext ] = pTemplateHash.split(':');
+		tmpViewHash = tmpViewHash.trim();
+		const tmpRecordSet = pRecord.RecordSet || '';
+		if (!tmpRecordSet)
+		{
+			this.pict.log.error(`Pict: Filter View Template Render: No record set specified in template hash [${pTemplateHash}] for view [${tmpViewHash}]`);
+			return fCallback(null, '');
+		}
+		const tmpRecordSetConfiguration = this.pict.PictSectionRecordSet.recordSetProviderConfigurations?.[tmpRecordSet];
+		if (!tmpRecordSetConfiguration)
+		{
+			this.pict.log.error(`Pict: Filter View Template Render: No record set configuration found for [${tmpRecordSet}] in template hash [${pTemplateHash}] for view [${tmpViewHash}]`);
+			return fCallback(null, '');
+		}
+		if (tmpViewContext)
+		{
+			tmpViewContext = tmpViewContext.trim();
+		}
+		else
+		{
+			tmpViewContext = 'Default';
+		}
+		if (!(tmpViewHash in this.pict.views))
+		{
+			this.log.warn(`Pict: Filter View Template Render: View not found for [${tmpViewHash}]`);
+			return fCallback(null, '');
+		}
+
+		pRecord = pRecord || {};
+		if (!pRecord.RecordSet)
+		{
+			pRecord.RecordSet = tmpRecordSet;
+		}
+		if (!pRecord.RecordSetConfiguration)
+		{
+			pRecord.RecordSetConfiguration = tmpRecordSetConfiguration;
+		}
+		if (!pRecord.ViewContext)
+		{
+			pRecord.ViewContext = pRecord.DashboardHash ? `${tmpViewContext}-${pRecord.DashboardHash}` : tmpViewContext;
+		}
+		let tmpRenderGUID = this.pict.getUUID();
+
+		/** @type {import('pict-view')} */
+		const tmpView = this.pict.views[tmpViewHash];
+
+		return tmpView.renderAsync('__Virtual', `__TemplateOutputCache.${tmpRenderGUID}`, pRecord,
+			(pError, pResult) =>
+			{
+				if (pError)
+				{
+					this.log.warn(`Pict: Filter View Template Render: Error rendering view [${tmpViewHash}]`, pError);
+					return fCallback(pError, '');
+				}
+
+				let tmpResult = this.pict.__TemplateOutputCache[tmpRenderGUID];
+				// TODO: Uncomment this when we like how it's working
+				//delete this.pict.__TemplateOutputCache[tmpRenderGUID];
+
+				return fCallback(null, tmpResult);
+			});
+	}
+}
+
+module.exports = PictTemplateFilterViewInstruction;

package/source/views/RecordSet-Filter.js

@@ -32,7 +32,7 @@ const _DEFAULT_CONFIGURATION_SUBSET_Filter =
 			Template: /*html*/`
 	<!-- DefaultPackage pict view template: [PRSP-SUBSET-Filter-Template] -->
 	<section id="PRSP_Filter_Container">
-		<form id="PRSP_Filter_Form" onsubmit="_Pict.views['PRSP-Filters'].handleSearch(event)">
+		<form id="PRSP_Filter_Form" onsubmit="_Pict.views['PRSP-Filters'].handleSearch(event, '{~D:Record.RecordSet~}', '{~D:Record.ViewContext~}'); return false;">
 			{~T:PRSP-SUBSET-Filter-Template-Input-Fieldset~}
 			{~T:PRSP-SUBSET-Filter-Template-Button-Fieldset~}
 		</form>
@@ -56,7 +56,7 @@ const _DEFAULT_CONFIGURATION_SUBSET_Filter =
 			Template: /*html*/`
 	<!-- DefaultPackage pict view template: [PRSP-SUBSET-Filter-Template-Button-Fieldset] -->
 	<fieldset>
-		<button type="button" id="PRSP_Filter_Button_Reset" onclick="_Pict.views['PRSP-Filters'].handleReset(event)">Reset</button>
+		<button type="button" id="PRSP_Filter_Button_Reset" onclick="_Pict.views['PRSP-Filters'].handleReset(event, '{~D:Record.RecordSet~}', '{~D:Record.ViewContext~}')">Reset</button>
 		<button type="submit" id="PRSP_Filter_Button_Apply">Apply</button>
 	</fieldset>
 	<!-- DefaultPackage end view template:	[PRSP-SUBSET-Filter-Template-Button-Fieldset] -->
@@ -83,20 +83,58 @@ class viewRecordSetSUBSETFilter extends libPictView
 	{
 		let tmpOptions = Object.assign({}, _DEFAULT_CONFIGURATION_SUBSET_Filter, pOptions);
 		super(pFable, tmpOptions, pServiceHash);
+		/** @type {import('fable') & import('pict') & { PictSectionRecordSet: import('../Pict-Section-RecordSet.js') }} */
+		this.pict;
 	}
 
-	handleSearch(event)
+	/**
+	 * @param {Event} pEvent - The DOM event that triggered the search
+	 * @param {string} pRecordSet - The record set being filtered
+	 * @param {string} pViewContext - The view context for the filter (ex. List, Dashboard)
+	 */
+	handleSearch(pEvent, pRecordSet, pViewContext)
 	{
-		event.preventDefault(); // don't submit the form
-		event.stopPropagation();
-		this.pict.views['RSP-RecordSet-List']?.handleSearch?.(this.pict.ContentAssignment.readContent('input[name="filter"]'));
+		pEvent.preventDefault(); // don't submit the form
+		pEvent.stopPropagation();
+		const tmpSearchString = this.pict.ContentAssignment.readContent(`input[name="filter"]`);
+		this.performSearch(pRecordSet, pViewContext, tmpSearchString ? String(tmpSearchString) : ' ');
 	}
 
-	handleReset(event)
+	/**
+	 * @param {string} pRecordSet - The record set being filtered
+	 * @param {string} pViewContext - The view context for the filter (ex. List, Dashboard)
+	 * @param {string} [pFilterString] - The filter string to apply, defaults to a single space if not provided
+	 */
+	performSearch(pRecordSet, pViewContext, pFilterString)
 	{
-		event.stopPropagation();
+		const tmpPictRouter = this.pict.providers.PictRouter;
+		const tmpProviderConfiguration = this.pict.PictSectionRecordSet.recordSetProviderConfigurations[pRecordSet];
+		let filterExpr = '%20';
+		if (pFilterString)
+		{
+			/** @type {Array<string>} */
+			const searchFields = tmpProviderConfiguration?.SearchFields ?? [ 'Name' ];
+			filterExpr = searchFields.map((filterField) => `FBVOR~${filterField}~LK~${encodeURIComponent(`%${pFilterString}%`)}`).join('~');
+		}
+		let tmpURLTemplate = tmpProviderConfiguration[`RecordSetFilterURLTemplate-${pViewContext}`] || tmpProviderConfiguration[`RecordSetFilterURLTemplate-Default`];
+		const tmpURL = this.pict.parseTemplate(tmpURLTemplate,
+			{
+				RecordSet: pRecordSet,
+				FilterString: filterExpr,
+			});
+		tmpPictRouter.router.navigate(tmpURL);
+	}
+
+	/**
+	 * @param {Event} pEvent - The DOM event that triggered the search
+	 * @param {string} pRecordSet - The record set being filtered
+	 * @param {string} pViewContext - The view context for the filter (ex. List, Dashboard)
+	 */
+	handleReset(pEvent, pRecordSet, pViewContext)
+	{
+		pEvent.preventDefault();
 		this.pict.ContentAssignment.assignContent('input[name="filter"]', '');
-		this.pict.views['RSP-RecordSet-List']?.handleSearch?.('');
+		this.performSearch(pRecordSet, pViewContext);
 	}
 }
 

package/source/views/dashboard/RecordSet-Dashboard-HeaderDashboard.js

@@ -1,12 +1,12 @@
 const libPictView = require('pict-view');
 
 /** @type {Record<string, any>} */
-const _DEFAULT_CONFIGURATION_Dashboard_HeaderDashboard =
+const _DEFAULT_CONFIGURATION_Dashboard_HeaderList =
 {
-	ViewIdentifier: 'PRSP-Dashboard-HeaderDashboard',
+	ViewIdentifier: 'PRSP-Dashboard-HeaderList',
 
-	DefaultRenderable: 'PRSP_Renderable_HeaderDashboard',
-	DefaultDestinationAddress: '#PRSP_HeaderDashboard_Container',
+	DefaultRenderable: 'PRSP_Renderable_HeaderList',
+	DefaultDestinationAddress: '#PRSP_HeaderList_Container',
 	DefaultTemplateRecordAddress: false,
 
 	// If this is set to true, when the App initializes this will.
@@ -28,37 +28,37 @@ const _DEFAULT_CONFIGURATION_Dashboard_HeaderDashboard =
 	Templates:
 	[
 		{
-			Hash: 'PRSP-Dashboard-HeaderDashboard-Template',
+			Hash: 'PRSP-Dashboard-HeaderList-Template',
 			Template: /*html*/`
-	<!-- DefaultPackage pict view template: [PRSP-Dashboard-HeaderDashboard-Template] -->
-	<!-- DefaultPackage end view template:  [PRSP-Dashboard-HeaderDashboard-Template] -->
+	<!-- DefaultPackage pict view template: [PRSP-Dashboard-HeaderList-Template] -->
+	<!-- DefaultPackage end view template:	[PRSP-Dashboard-HeaderList-Template] -->
 `
-		}
+		},
 	],
 
 	Renderables:
 	[
 		{
-			RenderableHash: 'PRSP_Renderable_HeaderDashboard',
-			TemplateHash: 'PRSP-Dashboard-HeaderDashboard-Template',
-			DestinationAddress: '#PRSP_HeaderDashboard_Container',
+			RenderableHash: 'PRSP_Renderable_HeaderList',
+			TemplateHash: 'PRSP-Dashboard-HeaderList-Template',
+			DestinationAddress: '#PRSP_HeaderList_Container',
 			RenderMethod: 'replace'
-		}
+		},
 	],
 
-	Manifests: {}
+	Manifests: {},
 };
 
-class viewRecordSetDashboardHeaderDashboard extends libPictView
+class viewRecordSetListHeaderList extends libPictView
 {
 	constructor(pFable, pOptions, pServiceHash)
 	{
-		let tmpOptions = Object.assign({}, _DEFAULT_CONFIGURATION_Dashboard_HeaderDashboard, pOptions);
+		let tmpOptions = Object.assign({}, _DEFAULT_CONFIGURATION_Dashboard_HeaderList, pOptions);
 		super(pFable, tmpOptions, pServiceHash);
 	}
 }
 
-module.exports = viewRecordSetDashboardHeaderDashboard;
+module.exports = viewRecordSetListHeaderList;
 
-module.exports.default_configuration = _DEFAULT_CONFIGURATION_Dashboard_HeaderDashboard;
+module.exports.default_configuration = _DEFAULT_CONFIGURATION_Dashboard_HeaderList;
 

package/source/views/dashboard/RecordSet-Dashboard-PaginationBottom.js

@@ -0,0 +1,68 @@
+const libPictView = require('pict-view');
+
+/** @type {Record<string, any>} */
+const _DEFAULT_CONFIGURATION_List_PaginationBottom = (
+	{
+		ViewIdentifier: 'PRSP-Dashboard-PaginationBottom',
+
+		DefaultRenderable: 'PRSP_Renderable_PaginationBottom',
+		DefaultDestinationAddress: '#PRSP_PaginationBottom_Container',
+		DefaultTemplateRecordAddress: false,
+
+		// If this is set to true, when the App initializes this will.
+		// While the App initializes, initialize will be called.
+		AutoInitialize: false,
+		AutoInitializeOrdinal: 0,
+
+		// If this is set to true, when the App autorenders (on load) this will.
+		// After the App initializes, render will be called.
+		AutoRender: false,
+		AutoRenderOrdinal: 0,
+
+		AutoSolveWithApp: false,
+		AutoSolveOrdinal: 0,
+
+		CSS: false,
+		CSSPriority: 500,
+
+		Templates:
+			[
+				{
+					Hash: 'PRSP-Dashboard-PaginationBottom-Template',
+					Template: /*html*/`
+	<!-- DefaultPackage pict view template: [PRSP-Dashboard-PaginationBottom-Template] -->
+	<nav id="RSP_Lower_Pagination_Container">
+	{~T:PRSP-Dashboard-Pagination-Template-Description~}
+		{~T:PRSP-Dashboard-Pagination-Template-Buttons~}
+	</nav>
+	<!-- DefaultPackage end view template:  [PRSP-Dashboard-PaginationBottom-Template] -->
+	`
+				}
+			],
+
+		Renderables:
+			[
+				{
+					RenderableHash: 'PRSP_Renderable_PaginationBottom',
+					TemplateHash: 'PRSP-Dashboard-PaginationBottom-Template',
+					DestinationAddress: '#PRSP_PaginationBottom_Container',
+					RenderMethod: 'replace'
+				}
+			],
+
+		Manifests: {}
+	});
+
+class viewRecordSetListPaginationBottom extends libPictView
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		let tmpOptions = Object.assign({}, _DEFAULT_CONFIGURATION_List_PaginationBottom, pOptions);
+		super(pFable, tmpOptions, pServiceHash);
+	}
+}
+
+module.exports = viewRecordSetListPaginationBottom;
+
+module.exports.default_configuration = _DEFAULT_CONFIGURATION_List_PaginationBottom;
+