quikchat 1.1.13 → 1.1.15

package/dist/quikchat.esm.js

@@ -80,11 +80,55 @@ function _unsupportedIterableToArray(r, a) {
   }
 }
 
+// Auto-generated version file - DO NOT EDIT MANUALLY
+// This file is automatically updated by tools/updateVersion.js
+
+var quikchatVersion = {
+  version: "1.1.15",
+  license: "BSD-2",
+  url: "https://github/deftio/quikchat",
+  fun: true
+};
+
+/**
+ * QuikChat - A zero-dependency JavaScript chat widget for modern web applications
+ * @class quikchat
+ * @version 1.1.15
+ */
 var quikchat = /*#__PURE__*/function () {
   /**
+   * Creates a new QuikChat instance
+   * @constructor
+   * @param {string|HTMLElement} parentElement - CSS selector or DOM element to attach the chat widget to
+   * @param {Function} [onSend] - Callback function triggered when user sends a message
+   * @param {Object} [options] - Configuration options
+   * @param {string} [options.theme='quikchat-theme-light'] - CSS theme class name
+   * @param {boolean} [options.trackHistory=true] - Whether to track message history
+   * @param {Object} [options.titleArea] - Title area configuration
+   * @param {string} [options.titleArea.title='Chat'] - Title text/HTML
+   * @param {boolean} [options.titleArea.show=false] - Whether to show title area initially
+   * @param {'left'|'center'|'right'} [options.titleArea.align='center'] - Title alignment
+   * @param {Object} [options.messagesArea] - Messages area configuration
+   * @param {boolean} [options.messagesArea.alternating=true] - Alternate message colors
+   * @param {Object} [options.inputArea] - Input area configuration
+   * @param {boolean} [options.inputArea.show=true] - Whether to show input area initially
+   * @param {boolean} [options.sendOnEnter=true] - Send message on Enter key
+   * @param {boolean} [options.sendOnShiftEnter=false] - Send message on Shift+Enter
+   * @param {string} [options.instanceClass=''] - Additional CSS class for the widget instance
+   * @example
+   * // Basic usage
+   * const chat = new quikchat('#chat-container', (instance, message) => {
+   *   console.log('User sent:', message);
+   * });
    * 
-   * @param string or DOM element  parentElement 
-   * @param {*} meta 
+   * @example
+   * // With options
+   * const chat = new quikchat('#chat', handleMessage, {
+   *   theme: 'quikchat-theme-dark',
+   *   titleArea: { title: 'Support Chat', show: true },
+   *   sendOnEnter: false,
+   *   sendOnShiftEnter: true
+   * });
    */
   function quikchat(parentElement) {
     var onSend = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {};
@@ -105,7 +149,8 @@ var quikchat = /*#__PURE__*/function () {
         show: true
       },
       sendOnEnter: true,
-      sendOnShiftEnter: false
+      sendOnShiftEnter: false,
+      instanceClass: ''
     };
     var meta = _objectSpread2(_objectSpread2({}, defaultOpts), options); // merge options with defaults
 
@@ -117,6 +162,10 @@ var quikchat = /*#__PURE__*/function () {
     this._theme = meta.theme;
     this._onSend = onSend ? onSend : function () {}; // call back function for onSend
     this._createWidget();
+    if (meta.instanceClass) {
+      this._chatWidget.classList.add(meta.instanceClass);
+    }
+
     // title area
     if (meta.titleArea) {
       this.titleAreaSetContents(meta.titleArea.title, meta.titleArea.align);
@@ -140,6 +189,7 @@ var quikchat = /*#__PURE__*/function () {
     this.trackHistory = meta.trackHistory || true;
     this._historyLimit = 10000000;
     this._history = [];
+    this._activeTags = new Set();
 
     // send on enter / shift enter
     this.sendOnEnter = meta.sendOnEnter;
@@ -214,24 +264,100 @@ var quikchat = /*#__PURE__*/function () {
       this._onMessageAdded = callback;
     }
 
+    /**
+     * Sets the callback function for when content is appended to a message
+     * @param {Function} callback - Function to call when content is appended
+     * @param {quikchat} callback.instance - The QuikChat instance
+     * @param {number} callback.msgId - The ID of the message being appended to
+     * @param {string} callback.content - The content being appended
+     * @since 1.1.15
+     * @example
+     * chat.setCallbackonMessageAppend((instance, msgId, content) => {
+     *   console.log(`Appended "${content}" to message ${msgId}`);
+     * });
+     */
+  }, {
+    key: "setCallbackonMessageAppend",
+    value: function setCallbackonMessageAppend(callback) {
+      this._onMessageAppend = callback;
+    }
+
+    /**
+     * Sets the callback function for when a message's content is replaced
+     * @param {Function} callback - Function to call when content is replaced
+     * @param {quikchat} callback.instance - The QuikChat instance
+     * @param {number} callback.msgId - The ID of the message being replaced
+     * @param {string} callback.content - The new content
+     * @since 1.1.15
+     * @example
+     * chat.setCallbackonMessageReplace((instance, msgId, content) => {
+     *   console.log(`Message ${msgId} replaced with: ${content}`);
+     * });
+     */
+  }, {
+    key: "setCallbackonMessageReplace",
+    value: function setCallbackonMessageReplace(callback) {
+      this._onMessageReplace = callback;
+    }
+
+    /**
+     * Sets the callback function for when a message is deleted
+     * @param {Function} callback - Function to call when a message is deleted
+     * @param {quikchat} callback.instance - The QuikChat instance
+     * @param {number} callback.msgId - The ID of the deleted message
+     * @since 1.1.15
+     * @example
+     * chat.setCallbackonMessageDelete((instance, msgId) => {
+     *   console.log(`Message ${msgId} was deleted`);
+     * });
+     */
+  }, {
+    key: "setCallbackonMessageDelete",
+    value: function setCallbackonMessageDelete(callback) {
+      this._onMessageDelete = callback;
+    }
+
     // Public methods
+    /**
+     * Toggles the visibility of the title area
+     * @returns {void}
+     */
   }, {
     key: "titleAreaToggle",
     value: function titleAreaToggle() {
       this._titleArea.style.display === 'none' ? this.titleAreaShow() : this.titleAreaHide();
     }
+
+    /**
+     * Shows the title area
+     * @returns {void}
+     */
   }, {
     key: "titleAreaShow",
     value: function titleAreaShow() {
       this._titleArea.style.display = '';
       this._adjustMessagesAreaHeight();
     }
+
+    /**
+     * Hides the title area
+     * @returns {void}
+     */
   }, {
     key: "titleAreaHide",
     value: function titleAreaHide() {
       this._titleArea.style.display = 'none';
       this._adjustMessagesAreaHeight();
     }
+
+    /**
+     * Sets the contents of the title area
+     * @param {string} title - HTML content to display in the title area
+     * @param {'left'|'center'|'right'} [align='center'] - Text alignment
+     * @returns {void}
+     * @example
+     * chat.titleAreaSetContents('<h2>Support Chat</h2>', 'center');
+     */
   }, {
     key: "titleAreaSetContents",
     value: function titleAreaSetContents(title) {
@@ -239,6 +365,11 @@ var quikchat = /*#__PURE__*/function () {
       this._titleArea.innerHTML = title;
       this._titleArea.style.textAlign = align;
     }
+
+    /**
+     * Gets the current contents of the title area
+     * @returns {string} The HTML content of the title area
+     */
   }, {
     key: "titleAreaGetContents",
     value: function titleAreaGetContents() {
@@ -313,10 +444,33 @@ var quikchat = /*#__PURE__*/function () {
     value: function messagesAreaAlternateColorsGet() {
       return this._messagesArea.classList.contains('quikchat-messages-area-alt');
     }
-    // message functions
+    /**
+     * Adds a new message to the chat with full configuration options
+     * @param {Object} input - Message configuration object
+     * @param {string} [input.content=''] - Message content (HTML allowed)
+     * @param {string} [input.userString='user'] - Display name for the message sender
+     * @param {'left'|'right'|'center'} [input.align='right'] - Message alignment
+     * @param {string} [input.role='user'] - Role identifier (user, assistant, system)
+     * @param {number} [input.userID=-1] - User ID for the message
+     * @param {string|false} [input.timestamp=false] - ISO timestamp or false for auto
+     * @param {string|false} [input.updatedtime=false] - Last updated timestamp
+     * @param {boolean|'smart'} [input.scrollIntoView=true] - Scroll behavior (true/false/'smart')
+     * @param {boolean} [input.visible=true] - Whether message is initially visible
+     * @param {string[]} [input.tags=[]] - Tags for message categorization
+     * @returns {number} Message ID for the newly added message
+     * @example
+     * const msgId = chat.messageAddFull({
+     *   content: 'Hello!',
+     *   userString: 'Bot',
+     *   align: 'left',
+     *   scrollIntoView: 'smart',
+     *   tags: ['greeting']
+     * });
+     */
   }, {
     key: "messageAddFull",
     value: function messageAddFull() {
+      var _this2 = this;
       var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
         content: "",
         userString: "user",
@@ -326,13 +480,22 @@ var quikchat = /*#__PURE__*/function () {
         timestamp: false,
         updatedtime: false,
         scrollIntoView: true,
-        visible: true
+        visible: true,
+        tags: []
       };
       var msgid = this.msgid;
       var messageDiv = document.createElement('div');
       var msgidClass = 'quikchat-msgid-' + String(msgid).padStart(10, '0');
       'quikchat-userid-' + String(input.userString).padStart(10, '0'); // hash this..
       messageDiv.classList.add('quikchat-message', msgidClass, 'quikchat-structure');
+      if (Array.isArray(input.tags)) {
+        input.tags.forEach(function (tag) {
+          if (typeof tag === 'string' && /^[a-zA-Z0-9-]+$/.test(tag)) {
+            messageDiv.classList.add("quikchat-tag-".concat(tag));
+            _this2._activeTags.add(tag);
+          }
+        });
+      }
       this.msgid++;
       var userDiv = document.createElement('div');
       userDiv.innerHTML = input.userString;
@@ -361,10 +524,15 @@ var quikchat = /*#__PURE__*/function () {
         messageDiv.style.display = 'none';
       }
 
-      // Scroll to the last message only if the user is not actively scrolling up
-      if (!this.userScrolledUp || input.scrollIntoView) {
+      // Handle scroll behavior based on scrollIntoView parameter
+      // 'smart' = only scroll if near bottom, true = always scroll, false = never scroll
+      if (input.scrollIntoView === true) {
+        this.messageScrollToBottom();
+      } else if (input.scrollIntoView === 'smart' && !this.userScrolledUp) {
         this.messageScrollToBottom();
       }
+      // If scrollIntoView is false, don't scroll at all
+
       this._textEntry.value = '';
       this._adjustMessagesAreaHeight();
       this._handleShortLongMessageCSS(messageDiv, input.align); // Handle CSS for short/long messages
@@ -391,6 +559,24 @@ var quikchat = /*#__PURE__*/function () {
       }
       return msgid;
     }
+
+    /**
+     * Adds a new message to the chat (simplified version of messageAddFull)
+     * @param {string} [content=''] - Message content (HTML allowed)
+     * @param {string} [userString='user'] - Display name for the message sender
+     * @param {'left'|'right'|'center'} [align='right'] - Message alignment
+     * @param {string} [role='user'] - Role identifier (user, assistant, system)
+     * @param {boolean|'smart'} [scrollIntoView=true] - Scroll behavior
+     * @param {boolean} [visible=true] - Whether message is initially visible
+     * @param {string[]} [tags=[]] - Tags for message categorization
+     * @returns {number} Message ID for the newly added message
+     * @example
+     * // Simple message
+     * chat.messageAddNew('Hello!', 'User', 'right');
+     * 
+     * // Bot message with smart scroll
+     * chat.messageAddNew('Hi there!', 'Bot', 'left', 'assistant', 'smart');
+     */
   }, {
     key: "messageAddNew",
     value: function messageAddNew() {
@@ -400,17 +586,27 @@ var quikchat = /*#__PURE__*/function () {
       var role = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "user";
       var scrollIntoView = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
       var visible = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;
+      var tags = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : [];
       var retvalue = this.messageAddFull({
         content: content,
         userString: userString,
         align: align,
         role: role,
         scrollIntoView: scrollIntoView,
-        visible: visible
+        visible: visible,
+        tags: tags
       });
       // this.messageScrollToBottom();
       return retvalue;
     }
+
+    /**
+     * Removes a message from the chat by its ID
+     * @param {number} n - Message ID to remove
+     * @returns {boolean} True if message was removed, false if not found
+     * @example
+     * const success = chat.messageRemove(5);
+     */
   }, {
     key: "messageRemove",
     value: function messageRemove(n) {
@@ -430,11 +626,21 @@ var quikchat = /*#__PURE__*/function () {
         this._history.splice(this._history.findIndex(function (item) {
           return item.msgid === n;
         }), 1);
+
+        // Call the onMessageDelete callback if it exists
+        if (this._onMessageDelete) {
+          this._onMessageDelete(this, n);
+        }
       }
       return sucess;
     }
     /* returns the message html object from the DOM
     */
+    /**
+     * Gets the DOM element for a message by its ID
+     * @param {number} n - Message ID
+     * @returns {HTMLElement|null} The message DOM element or null if not found
+     */
   }, {
     key: "messageGetDOMObject",
     value: function messageGetDOMObject(n) {
@@ -449,6 +655,11 @@ var quikchat = /*#__PURE__*/function () {
     }
     /* returns the message content only
     */
+    /**
+     * Gets the content of a message by its ID
+     * @param {number} n - Message ID
+     * @returns {string} The message content or empty string if not found
+     */
   }, {
     key: "messageGetContent",
     value: function messageGetContent(n) {
@@ -500,10 +711,13 @@ var quikchat = /*#__PURE__*/function () {
         item.updatedtime = new Date().toISOString();
         success = true;
 
-        // Scroll to the last message only if the user is not actively scrolling up
-        if (!this.userScrolledUp) {
-          this._messagesArea.lastElementChild.scrollIntoView();
+        // Call the onMessageAppend callback if it exists
+        if (this._onMessageAppend) {
+          this._onMessageAppend(this, n, content);
         }
+
+        // Don't auto-scroll on append - let user control this
+        // Users can call messageScrollToBottom() if they want to scroll
       } catch (error) {
         console.log("".concat(String(n), " : Message ID not found"));
       }
@@ -526,10 +740,13 @@ var quikchat = /*#__PURE__*/function () {
         item.updatedtime = new Date().toISOString();
         success = true;
 
-        // Scroll to the last message only if the user is not actively scrolling up
-        if (!this.userScrolledUp) {
-          this._messagesArea.lastElementChild.scrollIntoView();
+        // Call the onMessageReplace callback if it exists
+        if (this._onMessageReplace) {
+          this._onMessageReplace(this, n, content);
         }
+
+        // Don't auto-scroll on append - let user control this
+        // Users can call messageScrollToBottom() if they want to scroll
       } catch (error) {
         console.log("".concat(String(n), " : Message ID not found"));
       }
@@ -665,6 +882,18 @@ var quikchat = /*#__PURE__*/function () {
      * @param {*} m 
      * @returns array of history messages
      */
+    /**
+     * Gets a slice of message history
+     * @param {number} [n] - Start index (defaults to 0)
+     * @param {number} [m] - End index (defaults to history length)
+     * @returns {Array} Array of message objects
+     * @example
+     * // Get first 10 messages
+     * const messages = chat.historyGet(0, 10);
+     * 
+     * // Get all messages
+     * const allMessages = chat.historyGet();
+     */
   }, {
     key: "historyGet",
     value: function historyGet(n, m) {
@@ -680,17 +909,204 @@ var quikchat = /*#__PURE__*/function () {
 
       return this._history.slice(n, m);
     }
+
+    /**
+     * Gets a copy of the entire message history
+     * @returns {Array} Complete array of all message objects
+     * @example
+     * const history = chat.historyGetAllCopy();
+     * console.log(`Total messages: ${history.length}`);
+     */
   }, {
     key: "historyGetAllCopy",
     value: function historyGetAllCopy() {
       return this._history.slice();
     }
+
+    /**
+     * Get a page of history messages with pagination support
+     * @param {number} page - Page number (1-based)
+     * @param {number} pageSize - Number of messages per page (default 50)
+     * @param {string} order - 'asc' for oldest first, 'desc' for newest first (default 'asc')
+     * @returns {object} Object with messages array, pagination info
+     */
+  }, {
+    key: "historyGetPage",
+    value: function historyGetPage() {
+      var page = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      var pageSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 50;
+      var order = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'asc';
+      var totalMessages = this._history.length;
+      var totalPages = Math.ceil(totalMessages / pageSize);
+      var currentPage = Math.max(1, Math.min(page, totalPages || 1));
+      var start, end;
+      if (order === 'desc') {
+        // For descending order, page 1 shows the newest messages
+        start = Math.max(0, totalMessages - currentPage * pageSize);
+        end = totalMessages - (currentPage - 1) * pageSize;
+      } else {
+        // For ascending order, page 1 shows the oldest messages
+        start = (currentPage - 1) * pageSize;
+        end = Math.min(start + pageSize, totalMessages);
+      }
+      var messages = this._history.slice(start, end);
+
+      // Reverse messages array if descending order requested
+      if (order === 'desc') {
+        messages.reverse();
+      }
+      return {
+        messages: messages,
+        pagination: {
+          currentPage: currentPage,
+          pageSize: pageSize,
+          totalPages: totalPages,
+          totalMessages: totalMessages,
+          hasNext: currentPage < totalPages,
+          hasPrevious: currentPage > 1,
+          order: order
+        }
+      };
+    }
+
+    /**
+     * Get information about history size and pagination
+     * @param {number} pageSize - Size to calculate pages for (default 50)
+     * @returns {object} History metadata
+     */
+    /**
+     * Search history for messages matching criteria
+     * @param {object} criteria - Search criteria object
+     * @param {string} criteria.text - Text to search for in message content
+     * @param {string} criteria.userString - Filter by user name
+     * @param {string} criteria.role - Filter by role
+     * @param {array} criteria.tags - Filter by tags (messages with any of these tags)
+     * @param {number} criteria.limit - Maximum results to return (default 100)
+     * @returns {array} Array of matching messages
+     */
+    /**
+     * Searches through message history with various filters
+     * @param {Object} [criteria={}] - Search criteria
+     * @param {string} [criteria.text] - Text to search for in message content
+     * @param {string} [criteria.userString] - Filter by specific user
+     * @param {string} [criteria.role] - Filter by role (user, assistant, system)
+     * @param {string[]} [criteria.tags] - Filter by tags (messages must have at least one)
+     * @param {number} [criteria.limit=100] - Maximum number of results
+     * @returns {Array} Array of matching messages
+     * @since 1.1.15
+     * @example
+     * // Search for messages containing 'error'
+     * const errors = chat.historySearch({ text: 'error' });
+     * 
+     * // Find all bot messages
+     * const botMessages = chat.historySearch({ role: 'assistant' });
+     * 
+     * // Complex search
+     * const results = chat.historySearch({
+     *   text: 'help',
+     *   userString: 'Support',
+     *   tags: ['urgent'],
+     *   limit: 20
+     * });
+     */
+  }, {
+    key: "historySearch",
+    value: function historySearch() {
+      var criteria = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var results = this._history;
+
+      // Filter by text content (case-insensitive)
+      if (criteria.text) {
+        var searchText = criteria.text.toLowerCase();
+        results = results.filter(function (msg) {
+          return msg.content.toLowerCase().includes(searchText);
+        });
+      }
+
+      // Filter by user
+      if (criteria.userString) {
+        results = results.filter(function (msg) {
+          return msg.userString === criteria.userString;
+        });
+      }
+
+      // Filter by role
+      if (criteria.role) {
+        results = results.filter(function (msg) {
+          return msg.role === criteria.role;
+        });
+      }
+
+      // Filter by tags (match any tag)
+      if (criteria.tags && criteria.tags.length > 0) {
+        results = results.filter(function (msg) {
+          return msg.tags && msg.tags.some(function (tag) {
+            return criteria.tags.includes(tag);
+          });
+        });
+      }
+
+      // Limit results
+      var limit = criteria.limit || 100;
+      if (results.length > limit) {
+        results = results.slice(0, limit);
+      }
+      return results;
+    }
+
+    /**
+     * Gets metadata and statistics about the message history
+     * @param {number} [pageSize=50] - Page size for calculating total pages
+     * @returns {Object} History information object
+     * @returns {number} returns.totalMessages - Total number of messages
+     * @returns {number} returns.totalPages - Total pages based on page size
+     * @returns {Object|null} returns.oldestMessage - First message info
+     * @returns {Object|null} returns.newestMessage - Last message info
+     * @returns {Object} returns.memoryUsage - Memory usage statistics
+     * @since 1.1.15
+     * @example
+     * const info = chat.historyGetInfo();
+     * console.log(`Messages: ${info.totalMessages}`);
+     * console.log(`Memory: ${info.memoryUsage.estimatedSize} bytes`);
+     */
+  }, {
+    key: "historyGetInfo",
+    value: function historyGetInfo() {
+      var pageSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 50;
+      var totalMessages = this._history.length;
+      return {
+        totalMessages: totalMessages,
+        totalPages: Math.ceil(totalMessages / pageSize),
+        oldestMessage: totalMessages > 0 ? {
+          msgid: this._history[0].msgid,
+          timestamp: this._history[0].timestamp,
+          userString: this._history[0].userString
+        } : null,
+        newestMessage: totalMessages > 0 ? {
+          msgid: this._history[totalMessages - 1].msgid,
+          timestamp: this._history[totalMessages - 1].timestamp,
+          userString: this._history[totalMessages - 1].userString
+        } : null,
+        memoryUsage: {
+          estimatedSize: JSON.stringify(this._history).length,
+          averageMessageSize: totalMessages > 0 ? Math.round(JSON.stringify(this._history).length / totalMessages) : 0
+        }
+      };
+    }
+
+    /**
+     * Clears all messages and resets the chat
+     * @returns {void}
+     * @example
+     * chat.historyClear(); // Removes all messages
+     */
   }, {
     key: "historyClear",
     value: function historyClear() {
       this.msgid = 0;
       this._messagesArea.innerHTML = "";
       this._history = [];
+      this._activeTags.clear();
     }
   }, {
     key: "historyGetLength",
@@ -715,7 +1131,7 @@ var quikchat = /*#__PURE__*/function () {
   }, {
     key: "historyRestoreAll",
     value: function historyRestoreAll(messageList) {
-      var _this2 = this;
+      var _this3 = this;
       // clear all messages and history
       this.historyClear();
 
@@ -724,7 +1140,7 @@ var quikchat = /*#__PURE__*/function () {
 
       // add all messages
       messageList.forEach(function (message) {
-        _this2.messageAddFull(message);
+        _this3.messageAddFull(message);
       });
     }
     /**
@@ -753,15 +1169,82 @@ var quikchat = /*#__PURE__*/function () {
      * 
      * @returns {object} - Returns the version and license information for the library.
      */
+    /**
+     * Gets the QuikChat version information
+     * @static
+     * @returns {Object} Version information object
+     * @returns {string} returns.version - Version number (e.g., '1.1.15')
+     * @returns {string} returns.license - License type (e.g., 'BSD-2')
+     * @returns {string} returns.url - Project URL
+     * @returns {boolean} returns.fun - Easter egg flag
+     * @example
+     * const version = quikchat.version();
+     * console.log(`QuikChat v${version.version}`);
+     */
+  }, {
+    key: "setTagVisibility",
+    value:
+    /**
+     * Sets visibility for all messages with a specific tag
+     * @param {string} tagName - Tag name to control
+     * @param {boolean} isVisible - Whether to show or hide messages with this tag
+     * @returns {boolean} True if successful, false if invalid tag name
+     * @since 1.1.14
+     * @example
+     * // Hide all system messages
+     * chat.setTagVisibility('system', false);
+     * 
+     * // Show urgent messages
+     * chat.setTagVisibility('urgent', true);
+     */
+    function setTagVisibility(tagName, isVisible) {
+      if (typeof tagName !== 'string' || !/^[a-zA-Z0-9-]+$/.test(tagName)) {
+        return false;
+      }
+      var className = "quikchat-show-tag-".concat(tagName);
+      if (isVisible) {
+        this._chatWidget.classList.add(className);
+      } else {
+        this._chatWidget.classList.remove(className);
+      }
+      this._updateMessageStyles();
+      return true;
+    }
+
+    /**
+     * Gets the visibility state of a tag
+     * @param {string} tagName - Tag name to check
+     * @returns {boolean} True if tag is visible, false otherwise
+     * @since 1.1.14
+     * @example
+     * const isVisible = chat.getTagVisibility('system');
+     */
+  }, {
+    key: "getTagVisibility",
+    value: function getTagVisibility(tagName) {
+      if (typeof tagName !== 'string' || !/^[a-zA-Z0-9-]+$/.test(tagName)) {
+        return false;
+      }
+      return this._chatWidget.classList.contains("quikchat-show-tag-".concat(tagName));
+    }
+
+    /**
+     * Gets all active tags in the chat
+     * @returns {string[]} Array of all tags currently in use
+     * @since 1.1.14
+     * @example
+     * const tags = chat.getActiveTags();
+     * console.log('Active tags:', tags);
+     */
+  }, {
+    key: "getActiveTags",
+    value: function getActiveTags() {
+      return Array.from(this._activeTags);
+    }
   }], [{
     key: "version",
     value: function version() {
-      return {
-        "version": "1.1.13",
-        "license": "BSD-2",
-        "url": "https://github/deftio/quikchat",
-        "fun": true
-      };
+      return quikchatVersion;
     }
 
     /**
@@ -781,6 +1264,21 @@ var quikchat = /*#__PURE__*/function () {
      * //Returns a 200 Lorem Ipsum characters starting from a random index
      * loremIpsum(200);
      */
+
+    /**
+     * Generates Lorem Ipsum placeholder text
+     * @static
+     * @param {number} [numChars] - Length of text to generate (random if not specified)
+     * @param {number} [startSpot] - Starting offset in Lorem text (random if not specified)
+     * @param {boolean} [startWithCapitalLetter=true] - Whether to capitalize first letter
+     * @returns {string} Generated Lorem Ipsum text
+     * @example
+     * // Generate 100 characters
+     * const text = quikchat.loremIpsum(100);
+     * 
+     * // Generate random length
+     * const randomText = quikchat.loremIpsum();
+     */
   }, {
     key: "loremIpsum",
     value: function loremIpsum(numChars) {
@@ -820,7 +1318,27 @@ var quikchat = /*#__PURE__*/function () {
     }
   }, {
     key: "tempMessageGenerator",
-    value: function tempMessageGenerator(domElement, content, interval) {
+    value:
+    /**
+     * Creates a temporary message that updates periodically
+     * @static
+     * @param {string|HTMLElement} domElement - Element selector or DOM element
+     * @param {string} content - Initial message content
+     * @param {number} interval - Update interval in milliseconds (min 100ms)
+     * @param {Function} [cb=null] - Callback to generate new content
+     * @param {string} cb.message - Current message
+     * @param {number} cb.count - Update count
+     * @returns {void}
+     * @example
+     * // Simple loading indicator
+     * quikchat.tempMessageGenerator('#loading', 'Loading', 500);
+     * 
+     * // Custom update function
+     * quikchat.tempMessageGenerator('#status', 'Processing', 1000, (msg, count) => {
+     *   return `Processing... ${count}%`;
+     * });
+     */
+    function tempMessageGenerator(domElement, content, interval) {
       var cb = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
       interval = Math.max(interval, 100); // Ensure at least 100ms interval