contents of zip

scripts/sections.js

@@ -0,0 +1,931 @@
+// Use strict
+"use strict";
+
+
+// Classes
+
+// Sections class
+class Sections {
+
+	// Public
+	
+		// Constructor
+		constructor(settings, message, version) {
+		
+			// Set settings
+			this.settings = settings;
+			
+			// Set message
+			this.message = message;
+			
+			// Set version
+			this.version = version;
+			
+			// Set sections
+			this.sections = {};
+			
+			// Set stack to setting's default value
+			this.stack = JSON.parse(Sections.SETTINGS_SECTIONS_STACK_DEFAULT_VALUE);
+			
+			// Set stack index to setting's default value
+			this.stackIndex = Sections.SETTINGS_SECTIONS_STACK_INDEX_DEFAULT_VALUE;
+			
+			// Set stack version
+			this.stackVersion = version.getVersion();
+			
+			// Set self
+			var self = this;
+			
+			// Once database is initialized
+			Database.onceInitialized(function() {
+			
+				// Return promise
+				return new Promise(function(resolve, reject) {
+				
+					// Return creating settings
+					return Promise.all([
+			
+						// Sections stack setting
+						self.settings.createValue(Sections.SETTINGS_SECTIONS_STACK_NAME, Sections.SETTINGS_SECTIONS_STACK_DEFAULT_VALUE),
+						
+						// Sections stack index setting
+						self.settings.createValue(Sections.SETTINGS_SECTIONS_STACK_INDEX_NAME, Sections.SETTINGS_SECTIONS_STACK_INDEX_DEFAULT_VALUE),
+						
+						// Sections stack version setting
+						self.settings.createValue(Sections.SETTINGS_SECTIONS_STACK_VERSION_NAME, self.stackVersion)
+						
+					]).then(function() {
+					
+						// Initialize settings
+						var settings = [
+						
+							// Sections stack setting
+							Sections.SETTINGS_SECTIONS_STACK_NAME,
+							
+							// Sections stack index setting
+							Sections.SETTINGS_SECTIONS_STACK_INDEX_NAME,
+							
+							// Sections stack version setting
+							Sections.SETTINGS_SECTIONS_STACK_VERSION_NAME
+						];
+					
+						// Return getting settings' values
+						return Promise.all(settings.map(function(setting) {
+						
+							// Return getting setting's value
+							return self.settings.getValue(setting);
+						
+						})).then(function(settingValues) {
+						
+							// Check if stack version changed
+							if(settingValues[settings.indexOf(Sections.SETTINGS_SECTIONS_STACK_VERSION_NAME)] !== self.stackVersion) {
+							
+								// Return setting settings to their default values
+								return Promise.all([
+						
+									// Sections stack setting
+									self.settings.setValue(Sections.SETTINGS_SECTIONS_STACK_NAME, Sections.SETTINGS_SECTIONS_STACK_DEFAULT_VALUE),
+									
+									// Sections stack index setting
+									self.settings.setValue(Sections.SETTINGS_SECTIONS_STACK_INDEX_NAME, Sections.SETTINGS_SECTIONS_STACK_INDEX_DEFAULT_VALUE)
+									
+								]).then(function() {
+								
+									// Return setting sections stack version setting to the current version
+									return self.settings.setValue(Sections.SETTINGS_SECTIONS_STACK_VERSION_NAME, self.stackVersion).then(function() {
+								
+										// Set stack to setting's default value
+										self.stack = JSON.parse(Sections.SETTINGS_SECTIONS_STACK_DEFAULT_VALUE);
+										
+										// Set stack index to setting's default value
+										self.stackIndex = Sections.SETTINGS_SECTIONS_STACK_INDEX_DEFAULT_VALUE;
+										
+										// Resolve
+										resolve();
+										
+									// Catch errors
+									}).catch(function(error) {
+									
+										// Reject
+										reject();
+									});
+								
+								// Catch errors
+								}).catch(function(error) {
+								
+									// Reject
+									reject();
+								});
+							}
+							
+							// Otherwise
+							else {
+						
+								// Set stack to setting's value
+								self.stack = JSON.parse(settingValues[settings.indexOf(Sections.SETTINGS_SECTIONS_STACK_NAME)]);
+								
+								// Set stack index to setting's value
+								self.stackIndex = settingValues[settings.indexOf(Sections.SETTINGS_SECTIONS_STACK_INDEX_NAME)];
+								
+								// Resolve
+								resolve();
+							}
+						
+						// Catch errors
+						}).catch(function(error) {
+						
+							// Reject
+							reject();
+						});
+						
+					// Catch errors
+					}).catch(function(error) {
+					
+						// Reject
+						reject();
+					});
+				});
+			});
+		}
+		
+		// Register section
+		registerSection(section) {
+		
+			// Append section to list
+			this.sections[section.getName()] = section;
+		}
+		
+		// Get stack length
+		getStackLength() {
+		
+			// Return stack length
+			return this.stack["length"];
+		}
+		
+		// Get stack index
+		getStackIndex() {
+		
+			// Return stack index
+			return this.stackIndex;
+		}
+		
+		// Set stack index
+		setStackIndex(stackIndex) {
+		
+			// Set stack index
+			this.stackIndex = stackIndex;
+		}
+		
+		// Get stack
+		getStack() {
+		
+			// Return stack
+			return this.stack;
+		}
+		
+		// Set stack
+		setStack(stack) {
+		
+			// Set stack
+			this.stack = stack;
+		}
+		
+		// Push state to stack
+		pushStateToStack(section) {
+		
+			// Check if state isn't going to the end of the stack
+			if(this.stackIndex !== this.stack["length"]) {
+			
+				// Remove everything in stack after current index
+				this.stack.splice(this.stackIndex);
+			}
+			
+			// Otherwise check if a state exists in the stack
+			else if(this.stackIndex !== 0) {
+			
+				// Get current section
+				var currentSection = this.sections[this.stack[this.stackIndex - 1]["Name"]];
+			
+				// Update current section's state in the stack
+				this.stack[this.stackIndex - 1] = {
+
+					// Name
+					"Name": currentSection.getName(),
+					
+					// State
+					"State": currentSection.getState()
+				};
+			}
+			
+			// Increment stack index
+			++this.stackIndex;
+			
+			// Append section's state to the stack
+			this.stack.push({
+
+				// Name
+				"Name": section.getName(),
+				
+				// State
+				"State": section.getState()
+			});
+			
+			// Set self
+			var self = this;
+			
+			// Return promise
+			return new Promise(function(resolve, reject) {
+			
+				// Return saving stack
+				return self.saveStack().then(function() {
+				
+					// Resolve
+					resolve();
+				
+				// Catch errors
+				}).catch(function(error) {
+				
+					// Reject error
+					reject(error);
+				});
+			});
+		}
+		
+		// Insert state in stack
+		insertStateInStack(sectionName, state, isTemporary = false) {
+		
+			// Check if no states exists in the stack
+			if(this.stackIndex === 0) {
+		
+				// Increment stack index
+				++this.stackIndex;
+			}
+		
+			// Insert section name and state in the stack
+			this.stack.splice(this.stackIndex - 1, 0, {
+
+				// Name
+				"Name": sectionName,
+				
+				// State
+				"State": state
+			});
+			
+			// Check if is temporary
+			if(isTemporary === true) {
+			
+				// Set that value in stack is temporary
+				this.stack[this.stackIndex - 1]["Temporary"] = true;
+			}
+			
+			// Otherwise
+			else {
+			
+				// Set self
+				var self = this;
+				
+				// Return promise
+				return new Promise(function(resolve, reject) {
+				
+					// Return saving stack
+					return self.saveStack().then(function() {
+					
+						// Resolve
+						resolve();
+					
+					// Catch errors
+					}).catch(function(error) {
+					
+						// Reject error
+						reject(error);
+					});
+				});
+			}
+		}
+		
+		// Update state in stack
+		updateStateInStack(section, state = Sections.NO_STATE) {
+		
+			// Set self
+			var self = this;
+		
+			// Return promise
+			return new Promise(function(resolve, reject) {
+			
+				// Check if current state in the stack is for the section
+				if(self.stackIndex !== 0 && self.stack[self.stackIndex - 1]["Name"] === section.getName()) {
+				
+					// Get if state is temporary
+					var isTemporary = "Temporary" in self.stack[self.stackIndex - 1] === true && self.stack[self.stackIndex - 1]["Temporary"] === true;
+					
+					// Check if not temporary and unlocked display is showing a minimal display
+					if(isTemporary === false && $("div.unlocked").hasClass("minimal") === true) {
+					
+						// Resolve
+						resolve();
+					}
+					
+					// Otherwise
+					else {
+					
+						// Update section's state in the stack
+						self.stack[self.stackIndex - 1] = {
+
+							// Name
+							"Name": section.getName(),
+							
+							// State
+							"State": (state === Sections.NO_STATE) ? section.getState() : state
+						};
+						
+						// Check if is temporary
+						if(isTemporary === true) {
+						
+							// Set that value in stack is temporary
+							self.stack[self.stackIndex - 1]["Temporary"] = true;
+						}
+						
+						// Return saving stack
+						return self.saveStack().then(function() {
+						
+							// Resolve
+							resolve();
+						
+						// Catch errors
+						}).catch(function(error) {
+						
+							// Reject error
+							reject(error);
+						});
+					}
+				}
+				
+				// Otherwise
+				else {
+				
+					// Reject
+					reject();
+				}
+			});
+		}
+		
+		// Update stack
+		updateStack() {
+		
+			// Set current state to no state
+			var currentState = Sections.NO_STATE;
+		
+			// Check if a state exists in the stack
+			if(this.stackIndex !== 0) {
+			
+				// Get current section
+				var currentSection = this.sections[this.stack[this.stackIndex - 1]["Name"]];
+		
+				// Check if current state in the stack is for the current section
+				if(this.stack[this.stackIndex - 1]["Name"] === currentSection.getName()) {
+				
+					// Get current section's state
+					currentState = currentSection.getState();
+				}
+			}
+			
+			// Otherwise
+			else {
+			
+				// Set current section to no section
+				var currentSection = Sections.NO_SECTION;
+			}
+		
+			// Set self
+			var self = this;
+		
+			// Return promise
+			return new Promise(function(resolve, reject) {
+			
+				// Check if a current section exists
+				if(currentSection !== Sections.NO_SECTION) {
+		
+					// Update current section's state in the stack
+					self.updateStateInStack(currentSection, currentState).then(function() {
+					
+						// Resolve
+						resolve();
+					
+					// Catch errors
+					}).catch(function(error) {
+					
+						// Reject error
+						reject(error);
+					});
+				}
+				
+				// Otherwise
+				else {
+				
+					// Reject
+					reject();
+				}
+			});
+		}
+		
+		// Clear stack
+		clearStack(saveStack = false) {
+		
+			// Set stack to setting's default value
+			this.stack = JSON.parse(Sections.SETTINGS_SECTIONS_STACK_DEFAULT_VALUE);
+			
+			// Set stack index to setting's default value
+			this.stackIndex = Sections.SETTINGS_SECTIONS_STACK_INDEX_DEFAULT_VALUE;
+			
+			// Check if saving stack
+			if(saveStack === true) {
+			
+				// Set self
+				var self = this;
+			
+				// Return promise
+				return new Promise(function(resolve, reject) {
+				
+					// Return saving stack
+					return self.saveStack().then(function() {
+					
+						// Resolve
+						resolve();
+				
+					// Catch errors
+					}).catch(function(error) {
+					
+						// Reject error
+						reject(error);
+					});
+				});
+			}
+		}
+		
+		// Get current section
+		getCurrentSection() {
+		
+			// Return current section or no section if it doesn't exist
+			return (this.stackIndex !== 0) ? this.sections[this.stack[this.stackIndex - 1]["Name"]] : Sections.NO_SECTION;
+		}
+		
+		// Get current section name
+		getCurrentSectionName() {
+		
+			// Return current section's name or the default section name if there is no current section
+			return (this.stackIndex !== 0) ? this.stack[this.stackIndex - 1]["Name"] : Sections.DEFAULT_SECTION_NAME;
+		}
+		
+		// Get current section state
+		getCurrentSectionState() {
+		
+			// Return current section's state or no state if there is no current section
+			return (this.stackIndex !== 0) ? this.stack[this.stackIndex - 1]["State"] : Section.NO_STATE;
+		}
+		
+		// Is current section temporary
+		isCurrentSectionTemporary() {
+		
+			// Return if current section is temporary
+			return this.stackIndex !== 0 && "Temporary" in this.stack[this.stackIndex - 1] === true && this.stack[this.stackIndex - 1]["Temporary"] === true;
+		}
+		
+		// Show current section
+		showCurrentSection(minimal = true) {
+		
+			// Check if not minimal
+			if(minimal === false) {
+			
+				// Prevent showing messages
+				this.message.prevent();
+			
+				// Check if a current section exists
+				if(this.stackIndex !== 0) {
+				
+					// Check if current section is temporary
+					if("Temporary" in this.stack[this.stackIndex - 1] === true && this.stack[this.stackIndex - 1]["Temporary"] === true) {
+					
+						// Remove current section from the stack
+						this.stack.splice(this.stackIndex - 1, 1);
+						
+						// Check if there's no more sections
+						if(this.stack["length"] === 0) {
+						
+							// Decrement stack index
+							--this.stackIndex;
+						}
+					}
+				}
+				
+				// Check if an extension request exists
+				if(Extension.getRequests()["length"] !== 0) {
+				
+					// Get request
+					var request = Extension.getRequests().shift();
+					
+					// Insert request into sections
+					this.insertStateInStack(request["Name"], request["State"], true);
+				}
+				
+				// Otherwise check if closing when done processing extension requests
+				else if(Extension.getCloseWhenDone() === true) {
+				
+					// Prevent extension from interrupting on close
+					Extension.preventInterruptOnClose();
+				
+					// Close
+					window.close();
+					
+					// Return promise
+					return new Promise(function(resolve, reject) {
+					
+					});
+				}
+			}
+		
+			// Initialize first stack value
+			var firstStackValue = false;
+		
+			// Check if no current sections exists
+			if(this.stackIndex === 0) {
+			
+				// Set current state to no state
+				var currentState = Section.NO_STATE;
+				
+				// Set current section to the default section
+				var currentSection = this.sections[Sections.DEFAULT_SECTION_NAME];
+				
+				// Set first stack value
+				firstStackValue = true;
+			}
+			
+			// Otherwise
+			else {
+		
+				// Get current state from stack
+				var currentState = this.stack[this.stackIndex - 1];
+				
+				// Get current section from state
+				var currentSection = this.sections[currentState["Name"]];
+			}
+			
+			// Set self
+			var self = this;
+			
+			// Return promise
+			return new Promise(function(resolve, reject) {
+			
+				// Check if minimal
+				if(minimal === true) {
+			
+					// Return showing current section with the current state
+					return currentSection.show(true, false, false, (currentState !== Section.NO_STATE) ? currentState["State"] : Section.NO_STATE, firstStackValue, true, currentState !== Section.NO_STATE && "Temporary" in currentState === true && currentState["Temporary"] === true).then(function() {
+					
+						// Resolve
+						resolve();
+					
+					// Catch errors
+					}).catch(function(error) {
+					
+						// Reject error
+						reject(error);
+					});
+				}
+				
+				// Otherwise
+				else {
+				
+					// Return showing current section with the current state
+					return currentSection.show(false, true, true, (currentState !== Section.NO_STATE) ? currentState["State"] : Section.NO_STATE, firstStackValue, false, currentState !== Section.NO_STATE && "Temporary" in currentState === true && currentState["Temporary"] === true).then(function() {
+					
+						// Allow showing messages
+						self.message.allow();
+						
+						// Resolve
+						resolve();
+					
+					// Catch errors
+					}).catch(function(error) {
+					
+						// Reject error
+						reject(error);
+					});
+				}
+			});
+		}
+		
+		// Show section
+		showSection(sectionName, saveCurrentDisplay = false, state = Section.NO_STATE) {
+		
+			// Prevent showing messages
+			this.message.prevent();
+			
+			// Set self
+			var self = this;
+			
+			// Return promise
+			return new Promise(function(resolve, reject) {
+			
+				// Return showing section
+				return self.sections[sectionName].show(false, true, true, state, true, saveCurrentDisplay).then(function() {
+				
+					// Allow showing messages
+					self.message.allow();
+				
+				// Catch errors
+				}).catch(function(error) {
+				
+					// Reject error
+					reject(error);
+				});
+			});
+		}
+		
+		// Show previous section
+		showPreviousSection() {
+		
+			// Get previous state
+			var previousState = this.getPreviousStateFromStack();
+			
+			// Get previous section
+			var previousSection = this.sections[previousState["Name"]];
+			
+			// Prevent showing messages
+			this.message.prevent();
+			
+			// Set self
+			var self = this;
+			
+			// Return promise
+			return new Promise(function(resolve, reject) {
+			
+				// Return showing previous section
+				return previousSection.show(false, true, true, previousState["State"], false, true).then(function() {
+				
+					// Allow showing messages
+					self.message.allow();
+					
+					// Resolve
+					resolve();
+				
+				// Catch errors
+				}).catch(function(error) {
+					
+					// Reject error
+					reject(error);
+				});
+			});
+		}
+		
+		// Show next section
+		showNextSection() {
+		
+			// Get next state
+			var nextState = this.getNextStateFromStack();
+			
+			// Get next section
+			var nextSection = this.sections[nextState["Name"]];
+			
+			// Prevent showing messages
+			this.message.prevent();
+			
+			// Set self
+			var self = this;
+			
+			// Return promise
+			return new Promise(function(resolve, reject) {
+			
+				// Return showing next section
+				return nextSection.show(false, true, true, nextState["State"], false, true).then(function() {
+				
+					// Allow showing messages
+					self.message.allow();
+					
+					// Resolve
+					resolve();
+				
+				// Catch errors
+				}).catch(function(error) {
+					
+					// Reject error
+					reject(error);
+				});
+			});
+		}
+		
+		// Reset
+		reset() {
+		
+			// Go through all sections
+			for(var sectionName in this.sections) {
+								
+				if(this.sections.hasOwnProperty(sectionName) === true) {
+				
+					// Get section
+					var section = this.sections[sectionName];
+					
+					// Reset section
+					section.reset();
+				}
+			}
+		}
+		
+		// Get section
+		getSection(display) {
+		
+			// Go through all sections
+			for(var sectionName in this.sections) {
+								
+				if(this.sections.hasOwnProperty(sectionName) === true) {
+				
+					// Get section
+					var section = this.sections[sectionName];
+					
+					// Check if section has the display
+					if(section.getDisplay().is(display) === true) {
+					
+						// Return section
+						return section;
+					}
+				}
+			}
+			
+			// Return no section
+			return Sections.NO_SECTION;
+		}
+		
+		// Is section in stack
+		isSectionInStack(sectionName) {
+		
+			// Go through the stack
+			for(var i = 0; i < this.stack["length"]; ++i) {
+			
+				// Check if section in the stack has the same name
+				if(this.stack[i]["Name"] === sectionName) {
+				
+					// Return true
+					return true;
+				}
+			}
+			
+			// Return false
+			return false;
+		}
+		
+		// No section
+		static get NO_SECTION() {
+		
+			// Return no section
+			return null;
+		}
+	
+	// Private
+	
+		// Save stack
+		saveStack() {
+		
+			// Set self
+			var self = this;
+		
+			// Return promise
+			return new Promise(function(resolve, reject) {
+			
+				// Get current stack
+				var currentStack = [];
+				
+				// Get current stack index
+				var currentStackIndex = self.stackIndex;
+				
+				// Go through all values in the stack
+				for(var i = 0; i < self.stack["length"]; ++i) {
+				
+					// Get value
+					var value = self.stack[i];
+					
+					// Check if value is temporary
+					if("Temporary" in value === true && value["Temporary"] === true) {
+					
+						// Check if value being removed affects the current stack index
+						if(currentStackIndex - 1 > i || i === currentStack["length"] - 1) {
+						
+							// Decrement current stack index
+							--currentStackIndex;
+						}
+					}
+					
+					// Otherwise
+					else {
+					
+						// Add value to current stack
+						currentStack.push(value);
+					}
+				}
+				
+				// Check if nothing is in the current stack
+				if(currentStack["length"] === 0) {
+				
+					// Set current stack index to zero
+					currentStackIndex = 0;
+				}
+				
+				// Return saving sections stack version setting
+				return self.settings.setValue(Sections.SETTINGS_SECTIONS_STACK_VERSION_NAME, self.stackVersion).then(function() {
+			
+					// Return saving settings
+					return Promise.all([
+				
+						// Save sections stack setting
+						self.settings.setValue(Sections.SETTINGS_SECTIONS_STACK_NAME, JSON.stringify(currentStack)),
+						
+						// Save sections stack index setting
+						self.settings.setValue(Sections.SETTINGS_SECTIONS_STACK_INDEX_NAME, currentStackIndex)
+					
+					]).then(function() {
+					
+						// Resolve
+						resolve();
+					
+					// Catch errors
+					}).catch(function(error) {
+					
+						// Reject error
+						reject(error);
+					});
+				
+				// Catch errors
+				}).catch(function(error) {
+				
+					// Reject error
+					reject(error);
+				});
+			});
+		}
+		
+		// Get previous state from stack
+		getPreviousStateFromStack() {
+		
+			// Decrement stack index
+			--this.stackIndex;
+			
+			// Return state at stack index
+			return this.stack[this.stackIndex - 1];
+		}
+		
+		// Get next state from stack
+		getNextStateFromStack() {
+		
+			// Increment stack index
+			++this.stackIndex;
+			
+			// Return state at stack index
+			return this.stack[this.stackIndex - 1];
+		}
+		
+		// Settings sections stack name
+		static get SETTINGS_SECTIONS_STACK_NAME() {
+		
+			// Return settings sections stack name
+			return "Sections Stack";
+		}
+		
+		// Settings sections stack default value
+		static get SETTINGS_SECTIONS_STACK_DEFAULT_VALUE() {
+		
+			// Return settings sections stack default value
+			return JSON.stringify([]);
+		}
+		
+		// Settings sections stack index name
+		static get SETTINGS_SECTIONS_STACK_INDEX_NAME() {
+		
+			// Return settings sections stack index name
+			return "Sections Stack Index";
+		}
+		
+		// Settings sections stack index default value
+		static get SETTINGS_SECTIONS_STACK_INDEX_DEFAULT_VALUE() {
+		
+			// Return settings sections stack index default value
+			return 0;
+		}
+		
+		// Settings sections stackversion name
+		static get SETTINGS_SECTIONS_STACK_VERSION_NAME() {
+		
+			// Return settings sections stack version name
+			return "Sections Stack Version";
+		}
+		
+		// Default section name
+		static get DEFAULT_SECTION_NAME() {
+		
+			// Return default section name
+			return WalletSection.NAME;
+		}
+}
+
+
+// Main function
+
+// Set global object's sections
+globalThis["Sections"] = Sections;