@kansnpms/storage-pipe
Version:
Browser storage and cookies monitoring - Real-time tracking of localStorage, sessionStorage, cookies, and IndexedDB
1,107 lines (1,044 loc) • 37.4 kB
JavaScript
/**
* Console Log Pipe Storage Monitor v2.5.0
* Real-time browser storage and cookies monitoring
* (c) 2025 Console Log Pipe Team
* Released under the MIT License
*/
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.StorageMonitor = factory());
})(this, (function () { 'use strict';
function _arrayLikeToArray(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
return n;
}
function _arrayWithHoles(r) {
if (Array.isArray(r)) return r;
}
function asyncGeneratorStep(n, t, e, r, o, a, c) {
try {
var i = n[a](c),
u = i.value;
} catch (n) {
return void e(n);
}
i.done ? t(u) : Promise.resolve(u).then(r, o);
}
function _asyncToGenerator(n) {
return function () {
var t = this,
e = arguments;
return new Promise(function (r, o) {
var a = n.apply(t, e);
function _next(n) {
asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
}
function _throw(n) {
asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
}
_next(void 0);
});
};
}
function _classCallCheck(a, n) {
if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
}
function _defineProperties(e, r) {
for (var t = 0; t < r.length; t++) {
var o = r[t];
o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
}
}
function _createClass(e, r, t) {
return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
writable: !1
}), e;
}
function _defineProperty(e, r, t) {
return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
value: t,
enumerable: !0,
configurable: !0,
writable: !0
}) : e[r] = t, e;
}
function _iterableToArray(r) {
if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
}
function _iterableToArrayLimit(r, l) {
var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (null != t) {
var e,
n,
i,
u,
a = [],
f = !0,
o = !1;
try {
if (i = (t = t.call(r)).next, 0 === l) {
if (Object(t) !== t) return;
f = !1;
} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
} catch (r) {
o = !0, n = r;
} finally {
try {
if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
} finally {
if (o) throw n;
}
}
return a;
}
}
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function ownKeys(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function (r) {
return Object.getOwnPropertyDescriptor(e, r).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread2(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
_defineProperty(e, r, t[r]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
});
}
return e;
}
function _regenerator() {
/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
var e,
t,
r = "function" == typeof Symbol ? Symbol : {},
n = r.iterator || "@@iterator",
o = r.toStringTag || "@@toStringTag";
function i(r, n, o, i) {
var c = n && n.prototype instanceof Generator ? n : Generator,
u = Object.create(c.prototype);
return _regeneratorDefine(u, "_invoke", function (r, n, o) {
var i,
c,
u,
f = 0,
p = o || [],
y = !1,
G = {
p: 0,
n: 0,
v: e,
a: d,
f: d.bind(e, 4),
d: function (t, r) {
return i = t, c = 0, u = e, G.n = r, a;
}
};
function d(r, n) {
for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
var o,
i = p[t],
d = G.p,
l = i[2];
r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
}
if (o || r > 1) return a;
throw y = !0, n;
}
return function (o, p, l) {
if (f > 1) throw TypeError("Generator is already running");
for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
try {
if (f = 2, i) {
if (c || (o = "next"), t = i[o]) {
if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
if (!t.done) return t;
u = t.value, c < 2 && (c = 0);
} else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
i = e;
} else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
} catch (t) {
i = e, c = 1, u = t;
} finally {
f = 1;
}
}
return {
value: t,
done: y
};
};
}(r, o, i), !0), u;
}
var a = {};
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
t = Object.getPrototypeOf;
var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
return this;
}), t),
u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
function f(e) {
return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
return this;
}), _regeneratorDefine(u, "toString", function () {
return "[object Generator]";
}), (_regenerator = function () {
return {
w: i,
m: f
};
})();
}
function _regeneratorDefine(e, r, n, t) {
var i = Object.defineProperty;
try {
i({}, "", {});
} catch (e) {
i = 0;
}
_regeneratorDefine = function (e, r, n, t) {
if (r) i ? i(e, r, {
value: n,
enumerable: !t,
configurable: !t,
writable: !t
}) : e[r] = n;else {
function o(r, n) {
_regeneratorDefine(e, r, function (e) {
return this._invoke(r, n, e);
});
}
o("next", 0), o("throw", 1), o("return", 2);
}
}, _regeneratorDefine(e, r, n, t);
}
function _slicedToArray(r, e) {
return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
}
function _toArray(r) {
return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest();
}
function _toPrimitive(t, r) {
if ("object" != typeof t || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != typeof i) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, "string");
return "symbol" == typeof i ? i : i + "";
}
function _unsupportedIterableToArray(r, a) {
if (r) {
if ("string" == typeof r) return _arrayLikeToArray(r, a);
var t = {}.toString.call(r).slice(8, -1);
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
}
}
/**
* StorageMonitor - Real-time browser storage and cookies monitoring
*
* Monitors and streams changes to:
* - Cookies
* - localStorage
* - sessionStorage
* - IndexedDB operations
*/
var StorageMonitor = /*#__PURE__*/function () {
function StorageMonitor() {
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
_classCallCheck(this, StorageMonitor);
this.config = _objectSpread2({
serverHost: options.serverHost || 'localhost',
serverPort: options.serverPort || 3002,
sessionId: options.sessionId || this._generateSessionId(),
enableCookies: options.enableCookies !== false,
enableLocalStorage: options.enableLocalStorage !== false,
enableSessionStorage: options.enableSessionStorage !== false,
enableIndexedDB: options.enableIndexedDB !== false,
pollInterval: options.pollInterval || 1000
}, options);
this.ws = null;
this.isConnected = false;
this.isMonitoring = false;
// Storage state tracking
this.previousState = {
cookies: new Map(),
localStorage: new Map(),
sessionStorage: new Map(),
indexedDB: new Map()
};
// Monitoring intervals
this.intervals = new Map();
// Original storage methods (for restoration)
this.originalMethods = {};
}
/**
* Initialize storage monitoring
*/
return _createClass(StorageMonitor, [{
key: "init",
value: (function () {
var _init = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
var _t;
return _regenerator().w(function (_context) {
while (1) switch (_context.p = _context.n) {
case 0:
_context.p = 0;
_context.n = 1;
return this._connectWebSocket();
case 1:
// Start monitoring
this._startMonitoring();
// Storage Monitor connected and monitoring
return _context.a(2, this);
case 2:
_context.p = 2;
_t = _context.v;
// Storage Monitor initialization failed
if (this.config.debug) {
// eslint-disable-next-line no-console
console.error('❌ Storage Monitor initialization failed:', _t);
}
throw _t;
case 3:
return _context.a(2);
}
}, _callee, this, [[0, 2]]);
}));
function init() {
return _init.apply(this, arguments);
}
return init;
}()
/**
* Stop monitoring and cleanup
*/
)
}, {
key: "stop",
value: function stop() {
// Stopping Storage Monitor
this.isMonitoring = false;
// Clear intervals
this.intervals.forEach(function (interval) {
return clearInterval(interval);
});
this.intervals.clear();
// Restore original methods
this._restoreOriginalMethods();
// Close WebSocket
if (this.ws) {
this.ws.close();
this.ws = null;
}
this.isConnected = false;
// Storage Monitor stopped
}
/**
* Get current storage state
*/
}, {
key: "getCurrentState",
value: function getCurrentState() {
return {
cookies: this._getCurrentCookies(),
localStorage: this._getCurrentLocalStorage(),
sessionStorage: this._getCurrentSessionStorage(),
indexedDB: this._getCurrentIndexedDBInfo()
};
}
/**
* Connect to WebSocket server
*/
}, {
key: "_connectWebSocket",
value: function _connectWebSocket() {
var _this = this;
return new Promise(function (resolve, reject) {
var wsUrl = "ws://".concat(_this.config.serverHost, ":").concat(_this.config.serverPort);
_this.ws = new WebSocket(wsUrl);
_this.ws.onopen = function () {
_this.isConnected = true;
// Send initial connection message
_this._sendMessage({
type: 'storage_connect',
sessionId: _this.config.sessionId,
timestamp: new Date().toISOString(),
config: {
enableCookies: _this.config.enableCookies,
enableLocalStorage: _this.config.enableLocalStorage,
enableSessionStorage: _this.config.enableSessionStorage,
enableIndexedDB: _this.config.enableIndexedDB
}
});
resolve();
};
_this.ws.onerror = function (error) {
if (_this.config.debug) {
// eslint-disable-next-line no-console
console.error('❌ Storage Monitor WebSocket error:', error);
}
reject(error);
};
_this.ws.onclose = function () {
_this.isConnected = false;
// Storage Monitor disconnected
};
_this.ws.onmessage = function (event) {
try {
var message = JSON.parse(event.data);
_this._handleServerMessage(message);
} catch (error) {
if (_this.config.debug) {
// eslint-disable-next-line no-console
console.error('Error parsing server message:', error);
}
}
};
});
}
/**
* Start monitoring all enabled storage types
*/
}, {
key: "_startMonitoring",
value: function _startMonitoring() {
this.isMonitoring = true;
// Initialize previous state with current state to properly detect changes
if (this.config.enableCookies) {
this.previousState.cookies = this._getCurrentCookies();
}
if (this.config.enableLocalStorage) {
this.previousState.localStorage = this._getCurrentLocalStorage();
}
if (this.config.enableSessionStorage) {
this.previousState.sessionStorage = this._getCurrentSessionStorage();
}
if (this.config.enableIndexedDB) {
this.previousState.indexedDB = new Map(); // IndexedDB state is more complex
}
// Send initial state
this._sendStorageUpdate('initial_state', this.getCurrentState());
if (this.config.enableCookies) {
this._startCookieMonitoring();
}
if (this.config.enableLocalStorage) {
this._startLocalStorageMonitoring();
}
if (this.config.enableSessionStorage) {
this._startSessionStorageMonitoring();
}
if (this.config.enableIndexedDB) {
this._startIndexedDBMonitoring();
}
}
/**
* Start cookie monitoring
*/
}, {
key: "_startCookieMonitoring",
value: function _startCookieMonitoring() {
var _this2 = this;
// Poll for cookie changes
var interval = setInterval(function () {
if (!_this2.isMonitoring) return;
var currentCookies = _this2._getCurrentCookies();
var changes = _this2._detectCookieChanges(currentCookies);
if (changes.hasChanges) {
_this2._sendStorageUpdate('cookies', changes);
}
}, this.config.pollInterval);
this.intervals.set('cookies', interval);
}
/**
* Start localStorage monitoring
*/
}, {
key: "_startLocalStorageMonitoring",
value: function _startLocalStorageMonitoring() {
var _this3 = this;
// Intercept localStorage methods
this._interceptStorageMethod('localStorage', 'setItem');
this._interceptStorageMethod('localStorage', 'removeItem');
this._interceptStorageMethod('localStorage', 'clear');
// Also poll for external changes
var interval = setInterval(function () {
if (!_this3.isMonitoring) return;
var currentStorage = _this3._getCurrentLocalStorage();
var changes = _this3._detectStorageChanges('localStorage', currentStorage);
if (changes.hasChanges) {
_this3._sendStorageUpdate('localStorage', changes);
}
}, this.config.pollInterval);
this.intervals.set('localStorage', interval);
}
/**
* Start sessionStorage monitoring
*/
}, {
key: "_startSessionStorageMonitoring",
value: function _startSessionStorageMonitoring() {
var _this4 = this;
// Intercept sessionStorage methods
this._interceptStorageMethod('sessionStorage', 'setItem');
this._interceptStorageMethod('sessionStorage', 'removeItem');
this._interceptStorageMethod('sessionStorage', 'clear');
// Also poll for external changes
var interval = setInterval(function () {
if (!_this4.isMonitoring) return;
var currentStorage = _this4._getCurrentSessionStorage();
var changes = _this4._detectStorageChanges('sessionStorage', currentStorage);
if (changes.hasChanges) {
_this4._sendStorageUpdate('sessionStorage', changes);
}
}, this.config.pollInterval);
this.intervals.set('sessionStorage', interval);
}
/**
* Start IndexedDB monitoring
*/
}, {
key: "_startIndexedDBMonitoring",
value: function _startIndexedDBMonitoring() {
var _this5 = this;
// This is more complex and will be implemented in the next iteration
// For now, just detect database existence
var interval = setInterval(function () {
if (!_this5.isMonitoring) return;
// const currentDB = this._getCurrentIndexedDBInfo();
// TODO: Implement IndexedDB change detection
}, this.config.pollInterval * 2); // Less frequent polling for IndexedDB
this.intervals.set('indexedDB', interval);
}
/**
* Generate unique session ID
*/
}, {
key: "_generateSessionId",
value: function _generateSessionId() {
return "clp_storage_".concat(Date.now(), "_").concat(Math.random().toString(36).substr(2, 9));
}
/**
* Send message to server
*/
}, {
key: "_sendMessage",
value: function _sendMessage(message) {
if (this.ws && this.ws.readyState === WebSocket.OPEN) {
this.ws.send(JSON.stringify(message));
}
}
/**
* Send storage update to server
*/
}, {
key: "_sendStorageUpdate",
value: function _sendStorageUpdate(type, data) {
this._sendMessage({
type: 'storage_update',
subType: type,
sessionId: this.config.sessionId,
timestamp: new Date().toISOString(),
data: data
});
}
/**
* Handle messages from server
*/
}, {
key: "_handleServerMessage",
value: function _handleServerMessage(message) {
switch (message.type) {
case 'storage_info':
// Storage Monitor server info received
break;
case 'storage_command':
this._handleServerCommand(message.data);
break;
}
}
/**
* Handle commands from server
*/
}, {
key: "_handleServerCommand",
value: function _handleServerCommand(command) {
switch (command.action) {
case 'get_current_state':
this._sendStorageUpdate('current_state', this.getCurrentState());
break;
case 'clear_storage':
this._clearStorage(command.storageType);
break;
}
}
/**
* Get current cookies
*/
}, {
key: "_getCurrentCookies",
value: function _getCurrentCookies() {
var cookies = new Map();
if (typeof document !== 'undefined' && document.cookie) {
document.cookie.split(';').forEach(function (cookie) {
var _cookie$trim$split = cookie.trim().split('='),
_cookie$trim$split2 = _toArray(_cookie$trim$split),
name = _cookie$trim$split2[0],
valueParts = _cookie$trim$split2.slice(1);
if (name) {
cookies.set(name, {
name: name,
value: valueParts.join('=') || '',
domain: window.location.hostname,
path: '/',
timestamp: new Date().toISOString()
});
}
});
}
return cookies;
}
/**
* Get current localStorage
*/
}, {
key: "_getCurrentLocalStorage",
value: function _getCurrentLocalStorage() {
var storage = new Map();
if (typeof localStorage !== 'undefined') {
for (var i = 0; i < localStorage.length; i++) {
var key = localStorage.key(i);
if (key) {
storage.set(key, {
key: key,
value: localStorage.getItem(key),
timestamp: new Date().toISOString()
});
}
}
}
return storage;
}
/**
* Get current sessionStorage
*/
}, {
key: "_getCurrentSessionStorage",
value: function _getCurrentSessionStorage() {
var storage = new Map();
if (typeof sessionStorage !== 'undefined') {
for (var i = 0; i < sessionStorage.length; i++) {
var key = sessionStorage.key(i);
if (key) {
storage.set(key, {
key: key,
value: sessionStorage.getItem(key),
timestamp: new Date().toISOString()
});
}
}
}
return storage;
}
/**
* Get current IndexedDB info
*/
}, {
key: "_getCurrentIndexedDBInfo",
value: function _getCurrentIndexedDBInfo() {
// Basic IndexedDB detection - full implementation would be more complex
var info = {
available: typeof indexedDB !== 'undefined',
databases: [],
timestamp: new Date().toISOString()
};
return info;
}
/**
* Detect cookie changes
*/
}, {
key: "_detectCookieChanges",
value: function _detectCookieChanges(currentCookies) {
var changes = {
hasChanges: false,
added: [],
modified: [],
deleted: [],
current: Array.from(currentCookies.values())
};
var previousCookies = this.previousState.cookies;
// Check for added and modified cookies
currentCookies.forEach(function (cookie, name) {
if (!previousCookies.has(name)) {
changes.added.push(cookie);
changes.hasChanges = true;
} else if (previousCookies.get(name).value !== cookie.value) {
changes.modified.push(_objectSpread2(_objectSpread2({}, cookie), {}, {
oldValue: previousCookies.get(name).value
}));
changes.hasChanges = true;
}
});
// Check for deleted cookies
previousCookies.forEach(function (cookie, name) {
if (!currentCookies.has(name)) {
changes.deleted.push(cookie);
changes.hasChanges = true;
}
});
// Update previous state
this.previousState.cookies = new Map(currentCookies);
return changes;
}
/**
* Detect storage changes (localStorage/sessionStorage)
*/
}, {
key: "_detectStorageChanges",
value: function _detectStorageChanges(storageType, currentStorage) {
var changes = {
hasChanges: false,
added: [],
modified: [],
deleted: [],
current: Array.from(currentStorage.values())
};
var previousStorage = this.previousState[storageType];
// Check for added and modified items
currentStorage.forEach(function (item, key) {
if (!previousStorage.has(key)) {
changes.added.push(item);
changes.hasChanges = true;
} else if (previousStorage.get(key).value !== item.value) {
changes.modified.push(_objectSpread2(_objectSpread2({}, item), {}, {
oldValue: previousStorage.get(key).value
}));
changes.hasChanges = true;
}
});
// Check for deleted items
previousStorage.forEach(function (item, key) {
if (!currentStorage.has(key)) {
changes.deleted.push(item);
changes.hasChanges = true;
}
});
// Update previous state
this.previousState[storageType] = new Map(currentStorage);
return changes;
}
/**
* Intercept storage methods for real-time monitoring
*/
}, {
key: "_interceptStorageMethod",
value: function _interceptStorageMethod(storageType, methodName) {
var _this6 = this;
// In test environment, we need to use the same localStorage/sessionStorage
// that the test is using. Try multiple approaches to find the right one.
var storage;
// First try: direct global reference (what tests usually use)
try {
storage = eval(storageType); // localStorage or sessionStorage
} catch (e) {
// eval failed, try other approaches
}
// Second try: global object
if (!storage && typeof global !== 'undefined' && global[storageType]) {
storage = global[storageType];
}
// Third try: window object (browser)
if (!storage && typeof window !== 'undefined' && window[storageType]) {
storage = window[storageType];
}
if (!storage) {
return;
}
var originalMethod = storage[methodName];
this.originalMethods["".concat(storageType, "_").concat(methodName)] = originalMethod;
// Check if the property is configurable
var descriptor = Object.getOwnPropertyDescriptor(storage, methodName);
if (descriptor && descriptor.configurable === false) {
return;
}
storage[methodName] = function () {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
// Call original method
var result = originalMethod.apply(storage, args);
// Send immediate update
setTimeout(function () {
var currentStorage = storageType === 'localStorage' ? _this6._getCurrentLocalStorage() : _this6._getCurrentSessionStorage();
var changes = _this6._detectStorageChanges(storageType, currentStorage);
if (changes.hasChanges) {
_this6._sendStorageUpdate(storageType, _objectSpread2(_objectSpread2({}, changes), {}, {
operation: methodName,
args: args
}));
}
}, 0);
return result;
};
}
/**
* Restore original storage methods
*/
}, {
key: "_restoreOriginalMethods",
value: function _restoreOriginalMethods() {
var _this7 = this;
Object.keys(this.originalMethods).forEach(function (key) {
var _key$split = key.split('_'),
_key$split2 = _slicedToArray(_key$split, 2),
storageType = _key$split2[0],
methodName = _key$split2[1];
// Support both browser and test environments
var storage;
if (typeof window !== 'undefined' && window[storageType]) {
storage = window[storageType];
} else if (typeof global !== 'undefined' && global[storageType]) {
storage = global[storageType];
} else {
// Fallback: try to get from global scope directly
storage = eval(storageType); // localStorage or sessionStorage
}
if (storage && _this7.originalMethods[key]) {
storage[methodName] = _this7.originalMethods[key];
}
});
this.originalMethods = {};
}
/**
* Clear storage (for server commands)
*/
}, {
key: "_clearStorage",
value: function _clearStorage(storageType) {
switch (storageType) {
case 'localStorage':
if (typeof localStorage !== 'undefined') {
localStorage.clear();
}
break;
case 'sessionStorage':
if (typeof sessionStorage !== 'undefined') {
sessionStorage.clear();
}
break;
case 'cookies':
this._clearAllCookies();
break;
}
}
/**
* Clear all cookies
*/
}, {
key: "_clearAllCookies",
value: function _clearAllCookies() {
if (typeof document !== 'undefined') {
document.cookie.split(';').forEach(function (cookie) {
var eqPos = cookie.indexOf('=');
var name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
document.cookie = "".concat(name, "=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/");
});
}
}
}]);
}(); // Export for different module systems
if (typeof module !== 'undefined' && module.exports) {
module.exports = StorageMonitor;
} else if (typeof window !== 'undefined') {
window.StorageMonitor = StorageMonitor;
}
/**
* Browser-specific storage monitoring API
* Provides a simple interface for web applications
*/
var BrowserStorageMonitor = {
instance: null,
/**
* Initialize storage monitoring
* @param {Object} options - Configuration options
* @returns {Promise<StorageMonitor>} - Storage monitor instance
*/
init: function init() {
var _arguments = arguments,
_this = this;
return _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
var options, config, _t;
return _regenerator().w(function (_context) {
while (1) switch (_context.p = _context.n) {
case 0:
options = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : {};
if (!_this.instance) {
_context.n = 1;
break;
}
return _context.a(2, _this.instance);
case 1:
// Default configuration for browser environment
config = _objectSpread2({
serverHost: 'localhost',
serverPort: 3002,
enableCookies: true,
enableLocalStorage: true,
enableSessionStorage: true,
enableIndexedDB: true,
pollInterval: 1000,
autoStart: true
}, options);
_this.instance = new StorageMonitor(config);
if (!config.autoStart) {
_context.n = 5;
break;
}
_context.p = 2;
_context.n = 3;
return _this.instance.init();
case 3:
_context.n = 5;
break;
case 4:
_context.p = 4;
_t = _context.v;
// Connection failed, but we still return the instance
// This allows the API to work even when the server is not running
console.warn('Storage Monitor server connection failed:', _t.message);
console.warn("Storage monitoring will work locally but won't stream to CLI");
case 5:
return _context.a(2, _this.instance);
}
}, _callee, null, [[2, 4]]);
}))();
},
/**
* Stop storage monitoring
*/
stop: function stop() {
if (this.instance) {
this.instance.stop();
this.instance = null;
}
},
/**
* Get current storage state
*/
getCurrentState: function getCurrentState() {
return this.instance ? this.instance.getCurrentState() : null;
},
/**
* Check if monitoring is active
*/
isMonitoring: function isMonitoring() {
return this.instance ? this.instance.isMonitoring : false;
},
/**
* Get connection status
*/
isConnected: function isConnected() {
return this.instance ? this.instance.isConnected : false;
},
/**
* Manual trigger for storage state check
*/
checkStorageChanges: function checkStorageChanges() {
if (this.instance && this.instance.isMonitoring) {
// Force a check of all storage types
var currentState = this.instance.getCurrentState();
this.instance._sendStorageUpdate('manual_check', currentState);
}
},
/**
* Add custom storage event listener
*/
onStorageChange: function onStorageChange(callback) {
if (this.instance) {
this.instance.onStorageChange = callback;
}
},
/**
* Remove storage event listener
*/
offStorageChange: function offStorageChange() {
if (this.instance) {
this.instance.onStorageChange = null;
}
}
};
/**
* Create a unified StorageMonitor API that matches documentation
* This provides the static methods that documentation expects
*/
// Create the unified API by directly copying methods (avoid .bind() issues)
var UnifiedStorageMonitor = {};
// Copy init method with proper context
UnifiedStorageMonitor.init = function (options) {
return BrowserStorageMonitor.init.call(BrowserStorageMonitor, options);
};
// Copy other methods
UnifiedStorageMonitor.stop = function () {
return BrowserStorageMonitor.stop.call(BrowserStorageMonitor);
};
UnifiedStorageMonitor.getCurrentState = function () {
return BrowserStorageMonitor.getCurrentState.call(BrowserStorageMonitor);
};
UnifiedStorageMonitor.isMonitoring = function () {
return BrowserStorageMonitor.isMonitoring.call(BrowserStorageMonitor);
};
UnifiedStorageMonitor.isConnected = function () {
return BrowserStorageMonitor.isConnected.call(BrowserStorageMonitor);
};
UnifiedStorageMonitor.checkStorageChanges = function () {
return BrowserStorageMonitor.checkStorageChanges.call(BrowserStorageMonitor);
};
UnifiedStorageMonitor.onStorageChange = function (callback) {
return BrowserStorageMonitor.onStorageChange.call(BrowserStorageMonitor, callback);
};
UnifiedStorageMonitor.offStorageChange = function () {
return BrowserStorageMonitor.offStorageChange.call(BrowserStorageMonitor);
};
// Provide access to the underlying BrowserStorageMonitor for advanced usage
UnifiedStorageMonitor._internal = BrowserStorageMonitor;
// Auto-initialize if window.ConsoleLogPipeStorage is configured
if (typeof window !== 'undefined' && window.ConsoleLogPipeStorage) {
var config = window.ConsoleLogPipeStorage;
BrowserStorageMonitor.init(config).catch(function () {
// Auto-initialization failed - silently ignore
});
}
// Export for different module systems
if (typeof module !== 'undefined' && module.exports) {
module.exports = UnifiedStorageMonitor; // Export the unified API
} else if (typeof window !== 'undefined') {
window.BrowserStorageMonitor = BrowserStorageMonitor;
// Export the unified StorageMonitor API (matches documentation)
window.StorageMonitor = UnifiedStorageMonitor;
}
// Export the unified API
return UnifiedStorageMonitor;
}));
//# sourceMappingURL=storage-monitor.umd.js.map