extwee 1.5.3 → 2.0.0

package/src/Passage.js

@@ -0,0 +1,202 @@
+/**
+ * @class Passage
+ * @module Passage
+ */
+export default class Passage {
+  /**
+   * Name of the Passage
+   *
+   * @private
+   */
+  #_name = null;
+
+  /**
+   * Internal array of tags
+   *
+   * @private
+   */
+  #_tags = [];
+
+  /**
+   * Internal metadata of passage
+   *
+   * @private
+   */
+  #_metadata = {};
+
+  /**
+   * Internal text of the passage
+   *
+   * @private
+   */
+  #_text = '';
+
+  /**
+   * Internal PID of passage
+   *
+   * @private
+   */
+  #_pid = -1;
+
+  /**
+   * @function Passage
+   * @class
+   * @param {string} name - Name
+   * @param {string} text - Content
+   * @param {Array} tags - Tags
+   * @param {object} metadata - Metadata
+   * @param {number} pid - Passage ID (PID)
+   */
+  constructor (name = '', text = '', tags = [], metadata = {}, pid = -1) {
+    // Set name
+    this.name = name;
+
+    // Set tags
+    this.tags = tags;
+
+    // Set metadata
+    this.metadata = metadata;
+
+    // Sets text
+    this.text = text;
+
+    // Sets pid
+    this.pid = pid;
+  }
+
+  /**
+   * Name
+   *
+   * @public
+   * @memberof Passage
+   * @returns {string} Name
+   */
+  get name () { return this.#_name; }
+
+  /**
+   * @param {string} s - Name to replace
+   */
+  set name (s) {
+    if (typeof s === 'string') {
+      this.#_name = s;
+    } else {
+      throw new Error('Name must be a String!');
+    }
+  }
+
+  /**
+   * Tags
+   *
+   * @public
+   * @memberof Passage
+   * @returns {Array} Tags
+   */
+  get tags () { return this.#_tags; }
+
+  /**
+   * @param {Array} t - Replacement array
+   */
+  set tags (t) {
+    // Test if tags is an array
+    if (Array.isArray(t)) {
+      this.#_tags = t;
+    } else {
+      throw new Error('Tags must be an array!');
+    }
+  }
+
+  /**
+   * Metadata
+   *
+   * @public
+   * @memberof Passage
+   * @returns {object} Metadata
+   */
+  get metadata () { return this.#_metadata; }
+
+  /**
+   * @param {object} m - Replacement object
+   */
+  set metadata (m) {
+    // Test if metadata was an object
+    if (typeof m === 'object') {
+      this.#_metadata = m;
+    } else {
+      throw new Error('Metadata should be an object literal!');
+    }
+  }
+
+  /**
+   * Text
+   *
+   * @public
+   * @memberof Passage
+   * @returns {string} Text
+   */
+  get text () { return this.#_text; }
+
+  /**
+   * @param {string} t - Replacement text
+   */
+  set text (t) {
+    // Test if text is a String
+    if (typeof t === 'string') {
+      this.#_text = t;
+    } else {
+      throw new Error('Text should be a String!');
+    }
+  }
+
+  /**
+   * Passage ID (PID)
+   *
+   * @public
+   * @memberof Passage
+   * @returns {number} Passage ID (PID)
+   */
+  get pid () { return this.#_pid; }
+
+  /**
+   * @param {number} p - Replacement PID
+   */
+  set pid (p) {
+    // Test if PID is a number
+    if (Number.isInteger(p)) {
+      this.#_pid = p;
+    } else {
+      throw new Error('PID should be a number!');
+    }
+  }
+
+  /**
+   * Return a String representation
+   *
+   * @public
+   * @memberof Passage
+   * @returns {string} String form of passage
+   */
+  toString () {
+    // Start empty string.
+    let content = '';
+    // Write the name
+    content += `:: ${this.name}`;
+
+    // Test if it has any tags
+    if (this.tags.length > 0) {
+      // Write output of tags
+      content += ` [${this.tags.join(' ')}]`;
+    }
+
+    // Check if any properties exist
+    if (Object.keys(this.metadata).length > 0) {
+      // Write out a space and then passage metadata
+      content += ` ${JSON.stringify(this.metadata)}`;
+    }
+
+    // Add newline, text, and two newlines
+    content += `\n${this.text}\n\n`;
+
+    // Return string.
+    return content;
+  }
+}

package/src/Story.js

@@ -0,0 +1,461 @@
+import Passage from './Passage.js';
+
+const name = 'extwee';
+const version = '2.0.0';
+
+/**
+ * @class Story
+ * @module Story
+ */
+export default class Story {
+  /**
+   * Internal start
+   *
+   * @private
+   */
+  #_start = '';
+
+  /**
+   * Internal IFID
+   *
+   * @private
+   */
+  #_IFID = ''
+
+  /**
+   * Internal story format
+   *
+   * @private
+   */
+  #_format = '';
+
+  /**
+   * Internal version of story format
+   */
+  #_formatVersion = '';
+
+  /**
+   * Internal zoom level
+   */
+  #_zoom = 0;
+
+  /**
+   * Passages
+   *
+   * @private
+   */
+  #_passages = [];
+
+  /**
+   * Creator
+   *
+   * @private
+   */
+  #_creator = '';
+
+  /**
+   * CreatorVersion
+   *
+   * @private
+   */
+  #_creatorVersion = '';
+
+  /**
+   * Metadata
+   *
+   * @private
+   */
+  #_metadata = null;
+
+  /**
+   * Tag Colors
+   *
+   * @private
+   */
+  #_tagColors = {};
+
+  /**
+   * Internal PID counter
+   *
+   * @private
+   */
+  #_PIDCounter = 1;
+
+  /**
+   * @function Story
+   * @class
+   */
+  constructor () {
+    // Store the creator and version
+    this.#_creator = name;
+    this.#_creatorVersion = version;
+    // Set metadata to an object
+    this.#_metadata = {};
+  }
+
+  /**
+   * Tag Colors object (each property is a tag and its color)
+   *
+   * @public
+   * @readonly
+   * @memberof Story
+   * @returns {object} tag colors array
+   */
+  get tagColors () { return this.#_tagColors; }
+
+  /**
+   * @param {object} a - Replacement tag colors
+   */
+  set tagColors (a) {
+    if (a instanceof Object) {
+      this.#_tagColors = a;
+    } else {
+      throw new Error('Tag colors must be an object!');
+    }
+  }
+
+  /**
+   * Interactive Fiction ID (IFID) of Story
+   *
+   * @public
+   * @readonly
+   * @memberof Story
+   * @returns {string} IFID
+   */
+  get IFID () { return this.#_IFID; }
+
+  /**
+   * @param {string} i - Replacement IFID
+   */
+  set IFID (i) {
+    if (typeof i === 'string') {
+      this.#_IFID = i;
+    } else {
+      throw new Error('IFID must be a String!');
+    }
+  }
+
+  /**
+   * Name of start passage
+   *
+   * @public
+   * @readonly
+   * @memberof Story
+   * @returns {string} start
+   */
+  get start () { return this.#_start; }
+
+  /**
+   * @param {string} s - Replacement start
+   */
+  set start (s) {
+    if (typeof s === 'string') {
+      this.#_start = s;
+    } else {
+      throw new Error('start (passage name) must be a String!');
+    }
+  }
+
+  /**
+   * Story format version of Story
+   *
+   * @public
+   * @readonly
+   * @memberof Story
+   * @returns {string} story format version
+   */
+  get formatVersion () { return this.#_formatVersion; }
+
+  /**
+   * @param {string} f - Replacement format version
+   */
+  set formatVersion (f) {
+    if (typeof f === 'string') {
+      this.#_formatVersion = f;
+    } else {
+      throw new Error('Story format version must be a String!');
+    }
+  }
+
+  /**
+   * Metadata of Story
+   *
+   * @public
+   * @readonly
+   * @memberof Story
+   * @returns {object} metadata of story
+   */
+  get metadata () { return this.#_metadata; }
+
+  /**
+   * @param {object} o - Replacement metadata
+   */
+  set metadata (o) {
+    if (typeof o === 'object') {
+      this.#_metadata = o;
+    } else {
+      throw new Error('Story metadata must be Object!');
+    }
+  }
+
+  /**
+   * Story format of Story
+   *
+   * @public
+   * @readonly
+   * @memberof Story
+   * @returns {string} format
+   */
+  get format () { return this.#_format; }
+
+  /**
+   * @param {string} f - Replacement format
+   */
+  set format (f) {
+    if (typeof f === 'string') {
+      this.#_format = f;
+    } else {
+      throw new Error('Story format must be a String!');
+    }
+  }
+
+  /**
+   * Program used to create Story
+   *
+   * @public
+   * @memberof Story
+   * @returns {string} Creator Program
+   */
+  get creator () { return this.#_creator; }
+
+  /**
+   * @param {string} c - Creator Program of Story
+   */
+  set creator (c) {
+    if (typeof c === 'string') {
+      this.#_creator = c;
+    } else {
+      throw new Error('Creator must be String');
+    }
+  }
+
+  /**
+   * Version used to create Story
+   *
+   * @public
+   * @memberof Story
+   * @returns {string} Version
+   */
+  get creatorVersion () { return this.#_creatorVersion; }
+
+  /**
+   * @param {string} c - Version of creator program
+   */
+  set creatorVersion (c) {
+    if (typeof c === 'string') {
+      this.#_creatorVersion = c;
+    } else {
+      throw new Error('Creator version must be a string!');
+    }
+  }
+
+  /**
+   * Zoom level
+   *
+   * @public
+   * @memberof Story
+   * @returns {number} Zoom level
+   */
+  get zoom () { return this.#_zoom; }
+
+  /**
+   * @param {number} n - Replacement zoom level
+   */
+  set zoom (n) {
+    if (typeof n === 'number') {
+      // Parse float with a fixed length and then force into Number
+      this.#_zoom = Number(Number.parseFloat(n).toFixed(2));
+    } else {
+      throw new Error('Zoom level must be a Number!');
+    }
+  }
+
+  /**
+   * Add a passage to the story
+   *
+   * @public
+   * @function addPassage
+   * @memberof Story
+   * @param {Passage} p - Passage to add to Story
+   */
+  addPassage (p) {
+    // Check if passed argument is a Passage
+    if (p instanceof Passage) {
+      // Does this passage already exist in the collection?
+      if (this.getPassageByName(p.name) === null) {
+        // StoryData is the only passage with special parsing needs.
+        // All other passages are added to the internal passages array.
+        if (p.name === 'StoryData') {
+          // Try to parse JSON
+          try {
+            // Attempt to parse storyData JSON
+            const metadata = JSON.parse(p.text);
+
+            // IFID
+            if (Object.prototype.hasOwnProperty.call(metadata, 'ifid')) {
+              this.IFID = metadata.ifid;
+            }
+
+            // format
+            if (Object.prototype.hasOwnProperty.call(metadata, 'format')) {
+              this.format = metadata.format;
+            }
+
+            // formatVersion
+            if (Object.prototype.hasOwnProperty.call(metadata, 'formatVersion')) {
+              this.formatVersion = metadata.formatVersion;
+            }
+
+            // zoom
+            if (Object.prototype.hasOwnProperty.call(metadata, 'zoom')) {
+              this.zoom = metadata.zoom;
+            }
+
+            // start
+            if (Object.prototype.hasOwnProperty.call(metadata, 'start')) {
+              this.start = metadata.start;
+            }
+
+            // tag colors
+            if (Object.prototype.hasOwnProperty.call(metadata, 'tag-colors')) {
+              this.tagColors = metadata['tag-colors'];
+            }
+          } catch (event) {
+            // Ignore errors
+          }
+        } else {
+          // Look for Start
+          if (p.name === 'Start' && this.start === '') {
+            // Set Start as starting passage (unless overwritten by start property)
+            this.start = 'Start';
+          }
+
+          // Test for default value.
+          // (This might occur if using Story directory
+          //  outside of using HTMLParser or TweeParser.)
+          if (p.pid === -1) {
+            // Set the internal counter.
+            p.pid = this.#_PIDCounter;
+            // Update the internal counter.
+            this.#_PIDCounter++;
+          }
+
+          // Push the passage to the array
+          this.#_passages.push(p);
+        }
+      } else {
+        // Warn user
+        console.warn('Ignored passage with same name as existing one!');
+      }
+    } else {
+      // We can only add passages to array
+      throw new Error('Can only add Passages to the story!');
+    }
+  }
+
+  /**
+   * Remove a passage from the story by name
+   *
+   * @public
+   * @function removePassage
+   * @memberof Story
+   * @param {string} name - Passage name to remove
+   */
+  removePassage (name) {
+    this.#_passages = this.#_passages.filter(passage => passage.name !== name);
+  }
+
+  /**
+   * Find passages by tag
+   *
+   * @public
+   * @function getPassagesByTag
+   * @memberof Story
+   * @param {string} t - Passage name to search for
+   * @returns {Array} Return array of passages
+   */
+  getPassagesByTag (t) {
+    // Look through passages
+    return this.#_passages.filter((passage) => {
+      // Look through each passage's tags
+      return passage.tags.some((tag) => t === tag);
+    });
+  }
+
+  /**
+   * Find passage by name
+   *
+   * @public
+   * @function getPassageByName
+   * @memberof Story
+   * @param {string} name - Passage name to search for
+   * @returns {Passage | null} Return passage or null
+   */
+  getPassageByName (name) {
+    // Look through passages
+    const results = this.#_passages.find((passage) => passage.name === name);
+    // Return entry or null, if not found
+    return results !== undefined ? results : null;
+  }
+
+  /**
+   * Find passage by PID
+   *
+   * @public
+   * @function getPassageByPID
+   * @memberof Story
+   * @param {number} pid - Passage PID to search for
+   * @returns {Passage | null} Return passage or null
+   */
+  getPassageByPID (pid) {
+    // Look through passages
+    const results = this.#_passages.find((passage) => passage.pid === pid);
+    // Return passages or null
+    return results !== undefined ? results : null;
+  }
+
+  /**
+   * Size (number of passages).
+   * Does not include StoryAuthor, StoryTitle, UserScript, or UserStylesheet passages
+   *
+   * @public
+   * @function size
+   * @memberof Story
+   * @returns {number} Return number of passages
+   */
+  size () {
+    return this.#_passages.length;
+  }
+
+  /**
+   * forEach-style iterator of passages in Story
+   *
+   * @public
+   * @function forEach
+   * @memberof Story
+   * @param {Function} callback - Callback function
+   */
+  forEach (callback) {
+    // Check if argument is a function
+    if (typeof callback !== 'function') {
+      // Throw error
+      throw new Error('Callback must be a function!');
+    }
+
+    // Use internal forEach
+    this.#_passages.forEach((element, index) => {
+      // Call callback function with element and index
+      callback(element, index);
+    });
+  }
+}