omegga 1.2.9 → 1.3.0

package/dist/omegga/index.js

@@ -1,53 +1,15 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.commandInjector = exports.LogWrangler = exports.auth = exports.OmeggaWrapper = exports.Player = exports.Plugin = void 0;
-// Plugin loader format
-exports.Plugin = __importStar(require("./plugin"));
-// Player interface
-exports.Player = __importStar(require("./player"));
-// acts as the interface between server logs and matchers
-exports.OmeggaWrapper = __importStar(require("./wrapper"));
-// auth token generation helpers
-exports.auth = __importStar(require("./auth"));
-// tackles the problem of reading brickadia logs
-exports.LogWrangler = __importStar(require("./logWrangler"));
-// injects commands that only need a log wrangler to function
-exports.commandInjector = __importStar(require("./commandInjector"));
-__exportStar(require("./types"), exports);
-//# sourceMappingURL=index.js.map
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const plugin = require("./plugin.js");
+const player = require("./player.js");
+const wrapper = require("./wrapper.js");
+const auth = require("./auth.js");
+const logWrangler = require("./logWrangler.js");
+const commandInjector = require("./commandInjector.js");
+exports.Plugin = plugin;
+exports.Player = player;
+exports.OmeggaWrapper = wrapper;
+exports.auth = auth;
+exports.LogWrangler = logWrangler;
+exports.commandInjector = commandInjector;
+//# sourceMappingURL=index.js.map

package/dist/omegga/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/omegga/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uBAAuB;AACvB,mDAAmC;AAEnC,mBAAmB;AACnB,mDAAmC;AAEnC,yDAAyD;AACzD,2DAA2C;AAE3C,gCAAgC;AAChC,+CAA+B;AAE/B,gDAAgD;AAChD,6DAA6C;AAE7C,6DAA6D;AAC7D,qEAAqD;AAErD,0CAAwB"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

package/dist/omegga/logWrangler.js

@@ -1,287 +1,236 @@
 "use strict";
-/*
-The wrapper combines the things looking at or waiting for logs with the actual server logs
-*/
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _LogWrangler_matchers, _LogWrangler_watchers;
-Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = __importDefault(require("../logger"));
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const logger = require("../logger.js");
 const GENERIC_LINE_REGEX = /^(\[(?<date>\d{4}\.\d\d.\d\d-\d\d.\d\d.\d\d:\d{3})\]\[\s*(?<counter>\d+)\])?(?<generator>\w+): (?<data>.+)$/;
 class LogWrangler {
-    constructor(omegga) {
-        // list of patterns and callbacks watching the brickadia logs in general
-        _LogWrangler_matchers.set(this, []);
-        // list of patterns and promises waiting for specific console logs
-        _LogWrangler_watchers.set(this, []);
-        // passthru functions
-        this.exec = cmd => omegga.writeln(cmd);
-        this.getPlayer = (arg) => omegga.getPlayer(arg);
-        this.getVersion = () => omegga.version;
-        // callback reads in new lines
-        this.callback = this.handleLog.bind(this);
-        this.addMatcher = this.addMatcher.bind(this);
-        this.addWatcher = this.addWatcher.bind(this);
-        this.watchLogArray = this.watchLogArray.bind(this);
-        this.watchLogChunk = this.watchLogChunk.bind(this);
-        this.omegga = omegga;
-    }
-    // add a new matcher to listen in on the logs
-    // pattern is regex or a function that returns a match
-    // callback is a function that receives the result of the pattern
-    // returns a deregister function
-    addMatcher(pattern, callback) {
-        if ((typeof pattern !== 'function' && !(pattern instanceof RegExp)) ||
-            typeof callback !== 'function')
-            return undefined;
-        // create the matcher from the callback and pattern, add it to the matchers
-        const matcher = { pattern, callback };
-        __classPrivateFieldGet(this, _LogWrangler_matchers, "f").push(matcher);
-        // return a function to remove this matcher from the list of matchers
-        return () => {
-            const index = __classPrivateFieldGet(this, _LogWrangler_matchers, "f").indexOf(matcher);
-            if (index > -1)
-                __classPrivateFieldGet(this, _LogWrangler_matchers, "f").splice(index, 0);
-        };
-    }
-    // wait for stdout to match this regex or matcher fn, returns the match or times out
-    // pattern is regex or a function that returns a match
-    // if bundle is set to true, it returns all matches after the timeout ends rather than resolving (can't be used with delay 0)
-    // exec is a function run after adding the watcher
-    // debounce (used with bundle) waits extra time after each match before timing out
-    // afterMatchDelay (used with debounce) indicates to run a new timeout after the first match
-    // last (used with bundle) is a function run on the match. when it returns true, the watcher resolves early
-    // returns a promise, rejects after timeout ends
-    addWatcher(pattern, { timeoutDelay = 50, bundle = false, debounce = false, afterMatchDelay = 0, last, exec, } = {}) {
-        if (typeof pattern !== 'function' && !(pattern instanceof RegExp))
-            return undefined;
-        return new Promise((resolve, reject) => {
-            // create the watcher
-            const watcher = {
-                pattern,
-                bundle,
-                debounce,
-                timeoutDelay,
-                afterMatchDelay,
-                last,
-                matches: [],
-            };
-            watcher.resolve = (...args) => {
-                clearTimeout(watcher.timeout);
-                resolve(args);
-            };
-            // remove helper
-            watcher.remove = () => {
-                const index = __classPrivateFieldGet(this, _LogWrangler_watchers, "f").indexOf(watcher);
-                if (index > -1) {
-                    __classPrivateFieldGet(this, _LogWrangler_watchers, "f").splice(index, 1);
-                }
-            };
-            // what the watcher dones when it completes
-            watcher.done = () => {
-                // remove the watcher if it exists
-                watcher.remove();
-                // if the bundle option is set to true, resolve on timeout end
-                if (bundle) {
-                    resolve(watcher.matches);
-                }
-                else {
-                    logger_1.default.verbose('Watcher', pattern.toString(), 'timed out');
-                    // reject the promise
-                    reject('timed out');
-                }
-            };
-            // if the delay is non 0, kill the promise after some time
-            if (timeoutDelay !== 0) {
-                watcher.timeout = setTimeout(watcher.done, timeoutDelay);
-            }
-            __classPrivateFieldGet(this, _LogWrangler_watchers, "f").push(watcher);
-            exec && exec();
-        });
+  // list of patterns and callbacks watching the brickadia logs in general
+  #matchers = [];
+  // list of patterns and promises waiting for specific console logs
+  #watchers = [];
+  constructor(omegga) {
+    this.exec = (cmd) => omegga.writeln(cmd);
+    this.getPlayer = (arg) => omegga.getPlayer(arg);
+    this.getVersion = () => omegga.version;
+    this.callback = this.handleLog.bind(this);
+    this.addMatcher = this.addMatcher.bind(this);
+    this.addWatcher = this.addWatcher.bind(this);
+    this.watchLogArray = this.watchLogArray.bind(this);
+    this.watchLogChunk = this.watchLogChunk.bind(this);
+    this.omegga = omegga;
+  }
+  // add a new matcher to listen in on the logs
+  // pattern is regex or a function that returns a match
+  // callback is a function that receives the result of the pattern
+  // returns a deregister function
+  addMatcher(pattern, callback) {
+    if (typeof pattern !== "function" && !(pattern instanceof RegExp) || typeof callback !== "function")
+      return void 0;
+    const matcher = { pattern, callback };
+    this.#matchers.push(matcher);
+    return () => {
+      const index = this.#matchers.indexOf(matcher);
+      if (index > -1) this.#matchers.splice(index, 0);
+    };
+  }
+  // wait for stdout to match this regex or matcher fn, returns the match or times out
+  // pattern is regex or a function that returns a match
+  // if bundle is set to true, it returns all matches after the timeout ends rather than resolving (can't be used with delay 0)
+  // exec is a function run after adding the watcher
+  // debounce (used with bundle) waits extra time after each match before timing out
+  // afterMatchDelay (used with debounce) indicates to run a new timeout after the first match
+  // last (used with bundle) is a function run on the match. when it returns true, the watcher resolves early
+  // returns a promise, rejects after timeout ends
+  addWatcher(pattern, {
+    timeoutDelay = 50,
+    bundle = false,
+    debounce = false,
+    afterMatchDelay = 0,
+    last,
+    exec
+  } = {}) {
+    if (typeof pattern !== "function" && !(pattern instanceof RegExp))
+      return void 0;
+    return new Promise((resolve, reject) => {
+      const watcher = {
+        pattern,
+        bundle,
+        debounce,
+        timeoutDelay,
+        afterMatchDelay,
+        last,
+        matches: []
+      };
+      watcher.resolve = (...args) => {
+        clearTimeout(watcher.timeout);
+        resolve(args);
+      };
+      watcher.remove = () => {
+        const index = this.#watchers.indexOf(watcher);
+        if (index > -1) {
+          this.#watchers.splice(index, 1);
+        }
+      };
+      watcher.done = () => {
+        watcher.remove();
+        if (bundle) {
+          resolve(watcher.matches);
+        } else {
+          logger.default.verbose("Watcher", pattern.toString(), "timed out");
+          reject("timed out");
+        }
+      };
+      if (timeoutDelay !== 0) {
+        watcher.timeout = setTimeout(watcher.done, timeoutDelay);
+      }
+      this.#watchers.push(watcher);
+      exec && exec();
+    });
+  }
+  // match a group of console logs that have the same counter (ran on the same thread)
+  // first is a function or 'index' for the index capture group that determines if this is match is the first log
+  // last is a function that determines if this match is the last log (and can terminate early)
+  // aftermatch delay is borrowed from addWatcher
+  watchLogChunk(cmd, pattern, {
+    first,
+    last,
+    afterMatchDelay = 10,
+    timeoutDelay = 100
+  } = {}) {
+    const logLineRegExp = /\[(?<date>\d{4}\.\d\d.\d\d-\d\d.\d\d.\d\d:\d{3})\]\[\s*(?<counter>\d+)\](?<rest>.*)$/;
+    let currentCounter = -1;
+    return this.addWatcher(
+      (line, _match) => {
+        const logLineMatch = line.match(logLineRegExp);
+        if (!logLineMatch) return;
+        const {
+          groups: { counter, rest }
+        } = logLineMatch;
+        const match = pattern instanceof RegExp ? rest.match(pattern) : pattern(rest, rest.match(GENERIC_LINE_REGEX));
+        if (!match && currentCounter !== -1) {
+          return "[OMEGGA_WATCHER_DONE]";
+        }
+        if (!match) return;
+        let isFirst = false;
+        if (first) {
+          if (typeof first === "function") isFirst = first(match);
+          else if (first === "index" && typeof match === "object" && "groups" in match)
+            isFirst = match.groups.index === "0";
+        } else {
+          isFirst = true;
+        }
+        if (currentCounter === -1 && isFirst) {
+          currentCounter = counter;
+        }
+        if (currentCounter === -1 && !isFirst) {
+          return;
+        }
+        if (counter !== currentCounter) {
+          if (Number(counter) - 1 + "" === currentCounter) {
+            currentCounter = counter;
+          } else {
+            return "[OMEGGA_WATCHER_DONE]";
+          }
+        }
+        return match;
+      },
+      {
+        last,
+        exec: () => this.exec(cmd),
+        bundle: true,
+        debounce: true,
+        timeoutDelay,
+        afterMatchDelay
+      }
+    );
+  }
+  // get a chunked array from the log
+  // patterns are actually regex and must have capture groups
+  // the itemPattern must have an (?<index>) capture group
+  // the return is in the format of:
+  /*
+    [{
+      item: (itemPattern group),
+      members: [
+        ...memberPattern groups,
+      ],
+    }, ...]
+  */
+  async watchLogArray(cmd, itemPattern, memberPattern) {
+    const results = await this.watchLogChunk(
+      cmd,
+      (line) => {
+        const itemMatch = line.match(itemPattern);
+        if (itemMatch) return ["item", itemMatch];
+        const memberMatch = line.match(memberPattern);
+        if (memberMatch) return ["member", memberMatch];
+      },
+      { first: (arr) => arr[0] === "item" && arr[1].groups.index === "0" }
+    );
+    const array = [];
+    for (const [type, { groups }] of results) {
+      if (type === "item") {
+        array.push({ item: groups, members: [] });
+      } else if (type === "member" && array.length > 0) {
+        array[array.length - 1].members.push(groups);
+      }
     }
-    // match a group of console logs that have the same counter (ran on the same thread)
-    // first is a function or 'index' for the index capture group that determines if this is match is the first log
-    // last is a function that determines if this match is the last log (and can terminate early)
-    // aftermatch delay is borrowed from addWatcher
-    watchLogChunk(cmd, pattern, { first, last, afterMatchDelay = 10, timeoutDelay = 100, } = {}) {
-        // we're focused on the counter part of this, the rest will be passed to the pattern matcher
-        const logLineRegExp = /\[(?<date>\d{4}\.\d\d.\d\d-\d\d.\d\d.\d\d:\d{3})\]\[\s*(?<counter>\d+)\](?<rest>.*)$/;
-        // keep track of the current log line
-        let currentCounter = -1;
-        // create the
-        return this.addWatcher((line, _match) => {
-            const logLineMatch = line.match(logLineRegExp);
-            if (!logLineMatch)
-                return;
-            // get the counter and rest of line from the log line match
-            const { groups: { counter, rest }, } = logLineMatch;
-            // run the regular pattern matcher
-            const match = pattern instanceof RegExp
-                ? rest.match(pattern)
-                : pattern(rest, rest.match(GENERIC_LINE_REGEX));
-            // end the watcher early if there is no match and the match has started (log chunks are uninterrupted)
-            // this usually means that two commands were run so quickly that the output occured on the same counter
-            if (!match && currentCounter !== -1) {
-                return '[OMEGGA_WATCHER_DONE]';
-            }
-            // ignore things that don't match
-            if (!match)
-                return;
-            // determine if this is the first log in the chunk
-            let isFirst = false;
-            // if there is a first parameter
-            if (first) {
-                // if it's a function, use that function to match
-                if (typeof first === 'function')
-                    isFirst = first(match);
-                // if it's 'index', use the index capture group
-                else if (first === 'index' &&
-                    typeof match === 'object' &&
-                    'groups' in match)
-                    isFirst = match.groups.index === '0';
-            }
-            else {
-                // otherwise, it doesn't matter
-                isFirst = true;
-            }
-            // assign counter if it's not set and it's the first, or no first function is set
-            if (currentCounter === -1 && isFirst) {
-                currentCounter = counter;
-            }
-            if (currentCounter === -1 && !isFirst) {
-                return;
-            }
-            // prematurely terminate the match if another log is found
-            if (counter !== currentCounter) {
-                // long running commands
-                if (Number(counter) - 1 + '' === currentCounter) {
-                    currentCounter = counter;
-                }
-                else {
-                    return '[OMEGGA_WATCHER_DONE]';
-                }
+    return array;
+  }
+  // check all the matchers against this line
+  handleLog(line) {
+    const logMatch = line.match(GENERIC_LINE_REGEX);
+    const patternMatchers = [
+      {
+        array: this.#matchers,
+        onMatch(match, matcher) {
+          matcher.callback?.(match);
+        }
+      },
+      {
+        array: this.#watchers,
+        onMatch(match, watcher) {
+          if (watcher.bundle) {
+            if (match === "[OMEGGA_WATCHER_DONE]") {
+              clearTimeout(watcher.timeout);
+              watcher.done();
+              return;
             }
-            // add the match to the bundle
-            return match;
-        }, {
-            last,
-            exec: () => this.exec(cmd),
-            bundle: true,
-            debounce: true,
-            timeoutDelay,
-            afterMatchDelay,
-        });
-    }
-    // get a chunked array from the log
-    // patterns are actually regex and must have capture groups
-    // the itemPattern must have an (?<index>) capture group
-    // the return is in the format of:
-    /*
-      [{
-        item: (itemPattern group),
-        members: [
-          ...memberPattern groups,
-        ],
-      }, ...]
-    */
-    async watchLogArray(cmd, itemPattern, memberPattern) {
-        const results = (await this.watchLogChunk(cmd, (line) => {
-            // match on items
-            const itemMatch = line.match(itemPattern);
-            if (itemMatch)
-                return ['item', itemMatch];
-            // match on members
-            const memberMatch = line.match(memberPattern);
-            if (memberMatch)
-                return ['member', memberMatch];
-        }, { first: arr => arr[0] === 'item' && arr[1].groups.index === '0' }));
-        const array = [];
-        // insert the results into the array
-        for (const [type, { groups }] of results) {
-            // insert an item into the array
-            if (type === 'item') {
-                array.push({ item: groups, members: [] });
-                // insert a member into an item
+            watcher.matches = [...watcher.matches, match];
+            if (watcher?.last?.(match)) {
+              clearTimeout(watcher.timeout);
+              watcher.done();
+              return;
             }
-            else if (type === 'member' && array.length > 0) {
-                array[array.length - 1].members.push(groups);
+            if (watcher.debounce) {
+              clearTimeout(watcher.timeout);
+              watcher.timeout = setTimeout(
+                watcher.done,
+                watcher.afterMatchDelay || watcher.timeoutDelay
+              );
             }
+          } else {
+            watcher.resolve(match);
+            watcher.remove();
+          }
         }
-        return array;
-    }
-    // check all the matchers against this line
-    handleLog(line) {
-        // generic match the log
-        const logMatch = line.match(GENERIC_LINE_REGEX);
-        // pattern matcher handlers
-        const patternMatchers = [
-            {
-                array: __classPrivateFieldGet(this, _LogWrangler_matchers, "f"),
-                onMatch(match, matcher) {
-                    var _a;
-                    (_a = matcher.callback) === null || _a === void 0 ? void 0 : _a.call(matcher, match);
-                },
-            },
-            {
-                array: __classPrivateFieldGet(this, _LogWrangler_watchers, "f"),
-                onMatch(match, watcher) {
-                    var _a;
-                    // if the watcher is in bundle mode, add the match to its matches
-                    if (watcher.bundle) {
-                        // allow the watcher to terminate early
-                        if (match === '[OMEGGA_WATCHER_DONE]') {
-                            clearTimeout(watcher.timeout);
-                            watcher.done();
-                            return;
-                        }
-                        watcher.matches = [...watcher.matches, match];
-                        // check if this is the last line and terminate early
-                        if ((_a = watcher === null || watcher === void 0 ? void 0 : watcher.last) === null || _a === void 0 ? void 0 : _a.call(watcher, match)) {
-                            clearTimeout(watcher.timeout);
-                            watcher.done();
-                            return;
-                        }
-                        // if the watcher is debounced, reset the timer
-                        if (watcher.debounce) {
-                            clearTimeout(watcher.timeout);
-                            watcher.timeout = setTimeout(watcher.done, watcher.afterMatchDelay || watcher.timeoutDelay);
-                        }
-                        // otherwise resolve with the result and remove the watcher from the list
-                    }
-                    else {
-                        watcher.resolve(match);
-                        watcher.remove();
-                    }
-                },
-            },
-        ];
-        // loop through matchers and run callbacks if they match
-        for (const { array, onMatch } of patternMatchers) {
-            // iterate in reverse because removing indices will not skip over any elements
-            for (let i = array.length - 1; i >= 0; i--) {
-                const matcher = array[i];
-                try {
-                    // run the match on a pattern or test with a function
-                    const match = matcher.pattern instanceof RegExp
-                        ? line.match(matcher.pattern)
-                        : matcher.pattern(line, logMatch);
-                    // if there's  match, handle it for this type of matcher
-                    if (match)
-                        onMatch(match, matcher);
-                }
-                catch (e) {
-                    logger_1.default.error('error in matcher', matcher.pattern, e);
-                }
-            }
+      }
+    ];
+    for (const { array, onMatch } of patternMatchers) {
+      for (let i = array.length - 1; i >= 0; i--) {
+        const matcher = array[i];
+        try {
+          const match = matcher.pattern instanceof RegExp ? line.match(matcher.pattern) : matcher.pattern(line, logMatch);
+          if (match)
+            onMatch(
+              match,
+              matcher
+            );
+        } catch (e) {
+          logger.default.error("error in matcher", matcher.pattern, e);
         }
+      }
     }
+  }
 }
-_LogWrangler_matchers = new WeakMap(), _LogWrangler_watchers = new WeakMap();
 exports.default = LogWrangler;
-//# sourceMappingURL=logWrangler.js.map
+//# sourceMappingURL=logWrangler.js.map