@gesslar/muddy 0.0.1

package/src/modules/MudletModule.js

@@ -0,0 +1,188 @@
+import {Sass, Util, Valid} from "@gesslar/toolkit"
+import {fragment} from "xmlbuilder2"
+
+/**
+ * Base class for all Mudlet module types (scripts, triggers, aliases, etc.).
+ */
+export default class MudletModule {
+  #meta = new Map()
+
+  /**
+   * Creates a new Mudlet module.
+   *
+   * @param {object} [object] - Configuration object
+   * @param {string} object.name - Module name
+   * @param {"yes" | "no"} object.isFolder - Whether this is a folder
+   * @param {"yes" | "no"} object.isActive - Whether this module is active
+   * @param {string} [object.packageName] - Package name
+   * @param {string} [object.script] - Lua script content
+   */
+  constructor(object={}) {
+    const {name, isFolder, isActive, packageName="", script=""} = (object ?? {})
+
+    Valid.type(name, "String", {allowEmpty: false})
+    Valid.assert(isFolder === "yes" || isFolder === "no", "isFolder must be 'yes' or 'no'.")
+    Valid.assert(isActive === "yes" || isActive === "no", "isActive must be 'yes' or 'no'.")
+    Valid.type(packageName, "String")
+    Valid.type(script, "String")
+
+    this.#meta.set("name", name)
+    this.#meta.set("isFolder", isFolder)
+    this.#meta.set("isActive", isActive)
+    this.#meta.set("script", script)
+    this.#meta.set("packageName", packageName) // i have no idea what this is used for
+    this.#meta.set("parent", null)
+    this.#meta.set("children", new Set())
+    this.#meta.set("id", Symbol(name))
+  }
+
+  /**
+   * Gets the module name.
+   *
+   * @returns {string}
+   */
+  get name() {
+    return this.#meta.get("name")
+  }
+
+  /**
+   * Gets the module's unique symbol ID.
+   *
+   * @returns {symbol}
+   */
+  get id() {
+    return this.#meta.get("id")
+  }
+
+  /**
+   * Gets whether this module is a folder.
+   *
+   * @returns {"yes" | "no"}
+   */
+  get isFolder() {
+    return this.#meta.get("isFolder")
+  }
+
+  /**
+   * Gets whether this module is active.
+   *
+   * @returns {"yes" | "no"}
+   */
+  get isActive() {
+    return this.#meta.get("isActive")
+  }
+
+  /**
+   * Gets the Lua script content.
+   *
+   * @returns {string}
+   */
+  get script() {
+    return this.#meta.get("script")
+  }
+
+  /**
+   * Gets the package name.
+   *
+   * @returns {string}
+   */
+  get packageName() {
+    return this.#meta.get("packageName")
+  }
+
+  /**
+   * Sets the parent module.
+   *
+   * @param {MudletModule | null} parent - Parent module
+   */
+  set parent(parent) {
+    if(this.parent)
+      throw Sass.new("Parent already set.")
+
+    this.#meta.set("parent", parent)
+  }
+
+  /**
+   * Gets the parent module.
+   *
+   * @returns {MudletModule | null}
+   */
+  get parent() {
+    return this.#meta.get("parent")
+  }
+
+  /**
+   * Adds a child module to this module.
+   *
+   * @param {MudletModule} child - Child module to add
+   * @returns {this}
+   */
+  addChild(child) {
+    if(this.#meta.get("children").has(child))
+      throw Sass.new(`Child '${child}' is already present.`)
+
+    this.#meta.get("children").add(child)
+    child.parent = this
+
+    this.#meta.set("isFolder", "yes")
+
+    return this
+  }
+
+  /**
+   * Gets the set of child modules.
+   *
+   * @returns {Set<MudletModule>}
+   */
+  get children() {
+    return this.#meta.get("children")
+  }
+
+  /**
+   * Iterates through all parent modules up the hierarchy.
+   *
+   * @yields {MudletModule}
+   */
+  *parents() {
+    let current = this.parent
+    while(current !== null) {
+      yield current
+      current = current.parent
+    }
+  }
+
+  toJSON() {
+    return Object.fromEntries(this.#meta)
+  }
+
+  toString() {
+    return `[${this.constructor.name}: ${this.name}]`
+  }
+
+  /**
+   * Converts this module to an XML fragment for Mudlet package format.
+   *
+   * @returns {import("xmlbuilder2").XMLBuilder}
+   */
+  toXMLFragment() {
+    const kind = this.constructor.name.toLowerCase()
+    const baseName = Util.capitalize(kind)
+    const tag = this.isFolder === "yes" ? `${baseName}Group` : baseName
+    const frag = fragment()
+    const children = this.children
+
+    const root = frag
+      .ele(tag, {isActive: this.isActive, isFolder: this.isFolder})
+      .ele({name: this.name}).up()
+      .ele({script: this.script}).up()
+      .ele({packageName: this.packageName}).up()
+
+    // If this is a folder, serialize its children as nested modules.
+    if(this.isFolder === "yes" && children && children.size > 0) {
+      for(const child of children)
+        root.import(child.toXMLFragment())
+    }
+
+    return frag
+  }
+}

package/src/modules/Script.js

@@ -0,0 +1,59 @@
+import {Collection, Valid} from "@gesslar/toolkit"
+
+import MudletModule from "./MudletModule.js"
+
+/**
+ * Script module - represents a Lua script in Mudlet with optional event handlers.
+ */
+export default class Script extends MudletModule {
+  #meta = new Map()
+
+  /**
+   * Creates a new Script module.
+   *
+   * @param {object} [object] - Configuration object
+   * @param {Array<string>} [object.eventHandlerList] - List of event handler names
+   */
+  constructor(object={}) {
+    super(object)
+
+    const {eventHandlerList=[]} = object
+
+    Valid.type(eventHandlerList, "Array")
+    Valid.assert(
+      eventHandlerList.length === 0 ||
+      Collection.isArrayUniform(eventHandlerList, "String"),
+      "eventHandlerList must be an empty or String array"
+    )
+
+    this.#meta.set("eventHandlerList", eventHandlerList)
+  }
+
+  /**
+   * Gets the list of event handler names.
+   *
+   * @returns {Array<string>} List of event handler names
+   */
+  get eventHandlerList() {
+    return this.#meta.get("eventHandlerList")
+  }
+
+  toJSON() {
+    return Object.assign(
+      super.toJSON(),
+      {...Object.fromEntries(this.#meta)}
+    )
+  }
+
+  toXMLFragment() {
+    const frag = super.toXMLFragment()
+
+    // Add eventHandlerList as a container with string children
+    const handlerList = frag.last().ele("eventHandlerList")
+    this.eventHandlerList.forEach(handler => handlerList.ele({string: handler}))
+
+    handlerList.up()
+
+    return frag
+  }
+}

package/src/modules/Timer.js

@@ -0,0 +1,76 @@
+import {Valid} from "@gesslar/toolkit"
+
+import MudletModule from "./MudletModule.js"
+
+export default class Timer extends MudletModule {
+  #meta = new Map()
+
+  constructor(object={}) {
+    super(object)
+
+    const {
+      command="",
+      time="00:00:00.000",
+      isTempTimer="no",
+      isOffsetTimer="no"
+    } = object
+
+    // Validate string fields
+    Valid.type(command, "String")
+
+    // Validate time format (hh:mm:ss.zzz)
+    Valid.type(time, "String")
+    const timePattern = /^[0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3}$/
+    Valid.assert(timePattern.test(time), "time must match format hh:mm:ss.zzz")
+
+    // Validate yes/no attributes
+    Valid.assert(isTempTimer === "yes" || isTempTimer === "no", "isTempTimer must be 'yes' or 'no'")
+    Valid.assert(isOffsetTimer === "yes" || isOffsetTimer === "no", "isOffsetTimer must be 'yes' or 'no'")
+
+    // Store metadata
+    this.#meta.set("command", command)
+    this.#meta.set("time", time)
+    this.#meta.set("isTempTimer", isTempTimer)
+    this.#meta.set("isOffsetTimer", isOffsetTimer)
+  }
+
+  get command() {
+    return this.#meta.get("command")
+  }
+
+  get time() {
+    return this.#meta.get("time")
+  }
+
+  get isTempTimer() {
+    return this.#meta.get("isTempTimer")
+  }
+
+  get isOffsetTimer() {
+    return this.#meta.get("isOffsetTimer")
+  }
+
+  toJSON() {
+    return Object.assign(
+      super.toJSON(),
+      {...Object.fromEntries(this.#meta)}
+    )
+  }
+
+  toXMLFragment() {
+    const frag = super.toXMLFragment()
+
+    // Add timer-specific attributes
+    const root = frag.first()
+    root.att("isTempTimer", this.isTempTimer)
+    root.att("isOffsetTimer", this.isOffsetTimer)
+
+    // Add elements in schema order (after name, script, packageName from Module)
+    frag
+      .last()
+      .ele({command: this.command}).up()
+      .ele({time: this.time}).up()
+
+    return frag
+  }
+}

package/src/modules/Trigger.js

@@ -0,0 +1,259 @@
+import {Collection, Valid} from "@gesslar/toolkit"
+
+import MudletModule from "./MudletModule.js"
+
+/*
+  Dear AI, before you come for me thinking that I don't know how to spell,
+  or (valid) know how to type, understand this:
+
+  gesslar@liam:~$ cd /git/Mudlet && rg conditonLineDelta | wc -l
+  210
+
+  I KNOW HOW TO SPELL AND TYPE CONDITION! Someone(s) who is(are) not me
+  needs this information. 🤷🏻 (and no, I'm not passing it along)
+*/
+
+export default class Trigger extends MudletModule {
+  #meta = new Map()
+
+  constructor(object={}) {
+    super(object)
+
+    const {
+      triggerType=0,
+      conditonLineDelta=0,
+      mStayOpen=0,
+      mCommand="",
+      mFgColor="#000000",
+      mBgColor="#000000",
+      mSoundFile="",
+      colorTriggerFgColor="#000000",
+      colorTriggerBgColor="#000000",
+      regexCodeList=[],
+      regexCodePropertyList=[],
+      isTempTrigger="no",
+      isMultiline="no",
+      isPerlSlashGOption="no",
+      isColorizerTrigger="no",
+      isFilterTrigger="no",
+      isSoundTrigger="no",
+      isColorTrigger="no",
+      isColorTriggerFg="no",
+      isColorTriggerBg="no"
+    } = object
+
+    // Validate triggerType (0-7)
+    Valid.type(triggerType, "Number")
+    Valid.assert(triggerType >= 0 && triggerType <= 7, "triggerType must be between 0 and 7")
+
+    // Validate integer fields
+    Valid.type(conditonLineDelta, "Number")
+    Valid.type(mStayOpen, "Number")
+    Valid.assert(mStayOpen >= 0, "mStayOpen must be non-negative")
+
+    // Validate string fields
+    Valid.type(mCommand, "String")
+    Valid.type(mSoundFile, "String")
+
+    // Validate color fields (hex or "transparent")
+    const colorPattern = /^(#[0-9A-Fa-f]{6}|transparent)$/
+    Valid.assert(colorPattern.test(mFgColor), "mFgColor must be hex color or 'transparent'")
+    Valid.assert(colorPattern.test(mBgColor), "mBgColor must be hex color or 'transparent'")
+    Valid.assert(colorPattern.test(colorTriggerFgColor), "colorTriggerFgColor must be hex color or 'transparent'")
+    Valid.assert(colorPattern.test(colorTriggerBgColor), "colorTriggerBgColor must be hex color or 'transparent'")
+
+    // Validate lists
+    Valid.type(regexCodeList, "Array")
+    Valid.assert(
+      regexCodeList.length === 0 || Collection.isArrayUniform(regexCodeList, "String"),
+      "regexCodeList must be an empty or String array"
+    )
+
+    Valid.type(regexCodePropertyList, "Array")
+    Valid.assert(
+      regexCodePropertyList.length === 0 || Collection.isArrayUniform(regexCodePropertyList, "Number"),
+      "regexCodePropertyList must be an empty or Number array"
+    )
+    regexCodePropertyList.forEach(val => {
+      Valid.assert(val >= 0 && val <= 7, "regexCodePropertyList values must be between 0 and 7")
+    })
+
+    // Validate yes/no attributes
+    const yesNoFields = [
+      "isTempTrigger", "isMultiline", "isPerlSlashGOption", "isColorizerTrigger",
+      "isFilterTrigger", "isSoundTrigger", "isColorTrigger", "isColorTriggerFg", "isColorTriggerBg"
+    ]
+    const yesNoValues = {
+      isTempTrigger,
+      isMultiline,
+      isPerlSlashGOption,
+      isColorizerTrigger,
+      isFilterTrigger,
+      isSoundTrigger,
+      isColorTrigger,
+      isColorTriggerFg,
+      isColorTriggerBg
+    }
+
+    yesNoFields.forEach(field => {
+      Valid.assert(
+        yesNoValues[field] === "yes" || yesNoValues[field] === "no",
+        `${field} must be 'yes' or 'no'`
+      )
+    })
+
+    // Store all metadata
+    this.#meta.set("triggerType", triggerType)
+    this.#meta.set("conditonLineDelta", conditonLineDelta)
+    this.#meta.set("mStayOpen", mStayOpen)
+    this.#meta.set("mCommand", mCommand)
+    this.#meta.set("mFgColor", mFgColor)
+    this.#meta.set("mBgColor", mBgColor)
+    this.#meta.set("mSoundFile", mSoundFile)
+    this.#meta.set("colorTriggerFgColor", colorTriggerFgColor)
+    this.#meta.set("colorTriggerBgColor", colorTriggerBgColor)
+    this.#meta.set("regexCodeList", regexCodeList)
+    this.#meta.set("regexCodePropertyList", regexCodePropertyList)
+    this.#meta.set("isTempTrigger", isTempTrigger)
+    this.#meta.set("isMultiline", isMultiline)
+    this.#meta.set("isPerlSlashGOption", isPerlSlashGOption)
+    this.#meta.set("isColorizerTrigger", isColorizerTrigger)
+    this.#meta.set("isFilterTrigger", isFilterTrigger)
+    this.#meta.set("isSoundTrigger", isSoundTrigger)
+    this.#meta.set("isColorTrigger", isColorTrigger)
+    this.#meta.set("isColorTriggerFg", isColorTriggerFg)
+    this.#meta.set("isColorTriggerBg", isColorTriggerBg)
+  }
+
+  get triggerType() {
+    return this.#meta.get("triggerType")
+  }
+
+  get conditonLineDelta() {
+    return this.#meta.get("conditonLineDelta")
+  }
+
+  get mStayOpen() {
+    return this.#meta.get("mStayOpen")
+  }
+
+  get mCommand() {
+    return this.#meta.get("mCommand")
+  }
+
+  get mFgColor() {
+    return this.#meta.get("mFgColor")
+  }
+
+  get mBgColor() {
+    return this.#meta.get("mBgColor")
+  }
+
+  get mSoundFile() {
+    return this.#meta.get("mSoundFile")
+  }
+
+  get colorTriggerFgColor() {
+    return this.#meta.get("colorTriggerFgColor")
+  }
+
+  get colorTriggerBgColor() {
+    return this.#meta.get("colorTriggerBgColor")
+  }
+
+  get regexCodeList() {
+    return this.#meta.get("regexCodeList")
+  }
+
+  get regexCodePropertyList() {
+    return this.#meta.get("regexCodePropertyList")
+  }
+
+  get isTempTrigger() {
+    return this.#meta.get("isTempTrigger")
+  }
+
+  get isMultiline() {
+    return this.#meta.get("isMultiline")
+  }
+
+  get isPerlSlashGOption() {
+    return this.#meta.get("isPerlSlashGOption")
+  }
+
+  get isColorizerTrigger() {
+    return this.#meta.get("isColorizerTrigger")
+  }
+
+  get isFilterTrigger() {
+    return this.#meta.get("isFilterTrigger")
+  }
+
+  get isSoundTrigger() {
+    return this.#meta.get("isSoundTrigger")
+  }
+
+  get isColorTrigger() {
+    return this.#meta.get("isColorTrigger")
+  }
+
+  get isColorTriggerFg() {
+    return this.#meta.get("isColorTriggerFg")
+  }
+
+  get isColorTriggerBg() {
+    return this.#meta.get("isColorTriggerBg")
+  }
+
+  toJSON() {
+    return Object.assign(
+      super.toJSON(),
+      {...Object.fromEntries(this.#meta)}
+    )
+  }
+
+  toXMLFragment() {
+    const frag = super.toXMLFragment()
+
+    // Add trigger-specific attributes
+    const root = frag.first()
+    root.att("isTempTrigger", this.isTempTrigger)
+    root.att("isMultiline", this.isMultiline)
+    root.att("isPerlSlashGOption", this.isPerlSlashGOption)
+    root.att("isColorizerTrigger", this.isColorizerTrigger)
+    root.att("isFilterTrigger", this.isFilterTrigger)
+    root.att("isSoundTrigger", this.isSoundTrigger)
+    root.att("isColorTrigger", this.isColorTrigger)
+    root.att("isColorTriggerFg", this.isColorTriggerFg)
+    root.att("isColorTriggerBg", this.isColorTriggerBg)
+
+    // Add elements in schema order
+    frag
+      .last()
+      .ele({triggerType: this.triggerType}).up()
+      .ele({conditonLineDelta: this.conditonLineDelta}).up()
+      .ele({mStayOpen: this.mStayOpen}).up()
+      .ele({mCommand: this.mCommand}).up()
+      .ele({mFgColor: this.mFgColor}).up()
+      .ele({mBgColor: this.mBgColor}).up()
+      .ele({mSoundFile: this.mSoundFile}).up()
+      .ele({colorTriggerFgColor: this.colorTriggerFgColor}).up()
+      .ele({colorTriggerBgColor: this.colorTriggerBgColor}).up()
+
+    // Add regexCodeList
+    const regexList = frag.last().ele("regexCodeList")
+    this.regexCodeList.forEach(code => {
+      regexList.ele({string: code})
+    })
+    regexList.up()
+
+    // Add regexCodePropertyList
+    const propertyList = frag.last().ele("regexCodePropertyList")
+    this.regexCodePropertyList.forEach(prop => {
+      propertyList.ele({integer: prop})
+    })
+    propertyList.up()
+
+    return frag
+  }
+}

package/src/modules/Variable.js

@@ -0,0 +1,82 @@
+import {Valid} from "@gesslar/toolkit"
+import {fragment} from "xmlbuilder2"
+
+export default class Variable {
+  #meta = new Map()
+
+  constructor(object={}) {
+    const {
+      name,
+      keyType=0,
+      value="",
+      valueType=0,
+      isActive="yes",
+      isFolder="no"
+    } = object
+
+    // Validate required fields
+    Valid.type(name, "String", {allowEmpty: false})
+    Valid.type(value, "String")
+
+    // Validate integer fields
+    Valid.type(keyType, "Number")
+    Valid.type(valueType, "Number")
+
+    // Validate yes/no attributes
+    Valid.assert(isActive === "yes" || isActive === "no", "isActive must be 'yes' or 'no'")
+    Valid.assert(isFolder === "yes" || isFolder === "no", "isFolder must be 'yes' or 'no'")
+
+    // Store metadata
+    this.#meta.set("name", name)
+    this.#meta.set("keyType", keyType)
+    this.#meta.set("value", value)
+    this.#meta.set("valueType", valueType)
+    this.#meta.set("isActive", isActive)
+    this.#meta.set("isFolder", isFolder)
+  }
+
+  get name() {
+    return this.#meta.get("name")
+  }
+
+  get keyType() {
+    return this.#meta.get("keyType")
+  }
+
+  get value() {
+    return this.#meta.get("value")
+  }
+
+  get valueType() {
+    return this.#meta.get("valueType")
+  }
+
+  get isActive() {
+    return this.#meta.get("isActive")
+  }
+
+  get isFolder() {
+    return this.#meta.get("isFolder")
+  }
+
+  toJSON() {
+    return Object.fromEntries(this.#meta)
+  }
+
+  toString() {
+    return `[Variable]`
+  }
+
+  toXMLFragment() {
+    const frag = fragment()
+
+    frag
+      .ele("VariableGroup", {isActive: this.isActive, isFolder: this.isFolder})
+      .ele({name: this.name}).up()
+      .ele({keyType: this.keyType}).up()
+      .ele({value: this.value}).up()
+      .ele({valueType: this.valueType}).up()
+
+    return frag
+  }
+}