@gesslar/toolkit 2.4.0 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gesslar/toolkit",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "description": "A collection of utilities for Node.js and browser environments.",
   "main": "./src/index.js",
   "type": "module",

package/src/lib/CappedDirectoryObject.js

@@ -157,6 +157,75 @@ export default class CappedDirectoryObject extends DirectoryObject {
     return true
   }
 
+  /**
+   * Returns the parent directory of this capped directory.
+   * Returns null only if this directory is at the cap (the "root" of the capped tree).
+   *
+   * Note: The returned parent is a plain DirectoryObject (not capped).
+   * Use getDirectory() for creating capped subdirectories.
+   *
+   * @returns {DirectoryObject|null} Parent directory or null if at cap root
+   * @example
+   * const capped = new TempDirectoryObject("myapp")
+   * const subdir = capped.getDirectory("data")
+   * console.log(subdir.parent.path) // Returns parent DirectoryObject
+   * console.log(capped.parent) // null (at cap root)
+   */
+  get parent() {
+    const capResolved = path.resolve(this.#cap)
+
+    // If we're at the cap, return null (cap is the "root")
+    if(this.path === capResolved) {
+      return null
+    }
+
+    // Otherwise return the parent (plain DirectoryObject, not capped)
+    return super.parent
+  }
+
+  /**
+   * Generator that walks up the directory tree, stopping at the cap.
+   * Yields parent directories from current up to (and including) the cap root.
+   *
+   * @returns {Generator<DirectoryObject>} Generator yielding parent DirectoryObject instances
+   * @example
+   * const capped = new TempDirectoryObject("myapp")
+   * const deep = capped.getDirectory("data").getDirectory("files")
+   * for(const parent of deep.walkUp) {
+   *   console.log(parent.path)
+   *   // .../myapp-ABC123/data/files
+   *   // .../myapp-ABC123/data
+   *   // .../myapp-ABC123 (stops at cap)
+   * }
+   */
+  *#walkUpCapped() {
+    const capResolved = path.resolve(this.#cap)
+
+    // Use super.walkUp but stop when we would go beyond the cap
+    for(const dir of super.walkUp) {
+      // Don't yield anything beyond the cap
+      if(!dir.path.startsWith(capResolved)) {
+        break
+      }
+
+      yield dir
+
+      // Stop after yielding the cap
+      if(dir.path === capResolved) {
+        break
+      }
+    }
+  }
+
+  /**
+   * Returns a generator that walks up to the cap.
+   *
+   * @returns {Generator<DirectoryObject>} Generator yielding parent directories
+   */
+  get walkUp() {
+    return this.#walkUpCapped()
+  }
+
   /**
    * Creates a new CappedDirectoryObject by extending this directory's path.
    *

package/src/lib/DirectoryObject.js

@@ -37,6 +37,7 @@ import Sass from "./Sass.js"
  * @property {boolean} temporary - Whether this is marked as a temporary directory
  * @property {boolean} isFile - Always false (this is a directory)
  * @property {boolean} isDirectory - Always true
+ * @property {DirectoryObject|null} parent - The parent directory (null if root)
  * @property {Promise<boolean>} exists - Whether the directory exists (async getter)
  * @property {Generator<DirectoryObject>} walkUp - Generator yielding parent directories up to root
  *
@@ -89,6 +90,14 @@ export default class DirectoryObject extends FS {
     temporary: null,
   })
 
+  /**
+   * Cached parent directory object
+   *
+   * @type {DirectoryObject|null|undefined}
+   * @private
+   */
+  #parent = undefined
+
   /**
    * Constructs a DirectoryObject instance.
    *
@@ -147,7 +156,8 @@ export default class DirectoryObject extends FS {
       module: this.module,
       extension: this.extension,
       isFile: this.isFile,
-      isDirectory: this.isDirectory
+      isDirectory: this.isDirectory,
+      parent: this.parent ? this.parent.path : null
     }
   }
 
@@ -253,6 +263,37 @@ export default class DirectoryObject extends FS {
     return this.#meta.temporary
   }
 
+  /**
+   * Returns the parent directory of this directory.
+   * Returns null if this directory is the root directory.
+   * Computed lazily on first access and cached.
+   *
+   * @returns {DirectoryObject|null} The parent directory or null if root
+   * @example
+   * const dir = new DirectoryObject('/path/to/directory')
+   * console.log(dir.parent.path) // '/path/to'
+   *
+   * const root = new DirectoryObject('/')
+   * console.log(root.parent) // null
+   */
+  get parent() {
+    // Return cached value if available
+    if(this.#parent !== undefined) {
+      return this.#parent
+    }
+
+    // Compute parent directory (null if we're at root)
+    const parentPath = path.dirname(this.path)
+    const isRoot = parentPath === this.path
+
+    // Cache and return
+    this.#parent = isRoot
+      ? null
+      : new DirectoryObject(parentPath, this.temporary)
+
+    return this.#parent
+  }
+
   /**
    * Recursively removes a temporary directory and all its contents.
    *

package/src/lib/FS.js

@@ -129,7 +129,7 @@ export default class FS {
   static relativeOrAbsolutePath(from, to) {
     const fromBasePath = from.isDirectory
       ? from.path
-      : from.directory?.path ?? path.dirname(from.path)
+      : from.parent?.path ?? path.dirname(from.path)
 
     const relative = path.relative(fromBasePath, to.path)
 

package/src/lib/FileObject.js

@@ -29,7 +29,7 @@ import Valid from "./Valid.js"
  * @property {string} extension - The file extension
  * @property {boolean} isFile - Always true for files
  * @property {boolean} isDirectory - Always false for files
- * @property {DirectoryObject} directory - The parent directory object
+ * @property {DirectoryObject} parent - The parent directory object
  * @property {Promise<boolean>} exists - Whether the file exists (async)
  */
 
@@ -58,7 +58,7 @@ export default class FileObject extends FS {
    * @property {string|null} extension - The file extension
    * @property {boolean} isFile - Always true
    * @property {boolean} isDirectory - Always false
-   * @property {DirectoryObject|null} directory - The parent directory object
+   * @property {DirectoryObject|null} parent - The parent directory object
    */
   #meta = Object.seal({
     supplied: null,
@@ -69,16 +69,16 @@ export default class FileObject extends FS {
     extension: null,
     isFile: true,
     isDirectory: false,
-    directory: null,
+    parent: null,
   })
 
   /**
    * Constructs a FileObject instance.
    *
    * @param {string | FileObject} fileName - The file path or FileObject
-   * @param {DirectoryObject|string|null} [directory] - The parent directory (object or string)
+   * @param {DirectoryObject|string|null} [parent] - The parent directory (object or string)
    */
-  constructor(fileName, directory=null) {
+  constructor(fileName, parent=null) {
     super()
 
     // If passed a FileObject, extract its path
@@ -93,19 +93,19 @@ export default class FileObject extends FS {
 
     const {dir,base,ext} = this.#deconstructFilenameToParts(fixedFile)
 
-    const directoryObject = (() => {
-      switch(Data.typeOf(directory)) {
+    const parentObject = (() => {
+      switch(Data.typeOf(parent)) {
         case "String":
-          return new DirectoryObject(directory)
+          return new DirectoryObject(parent)
         case "DirectoryObject":
         case "TempDirectoryObject":
-          return directory
+          return parent
         default:
           return new DirectoryObject(dir)
       }
     })()
 
-    const final = FS.resolvePath(directoryObject.path ?? ".", fixedFile)
+    const final = FS.resolvePath(parentObject.path ?? ".", fixedFile)
 
     const resolved = final
     const url = new URL(FS.pathToUri(resolved))
@@ -116,7 +116,7 @@ export default class FileObject extends FS {
     this.#meta.name = base
     this.#meta.extension = ext
     this.#meta.module = path.basename(this.supplied, this.extension)
-    this.#meta.directory = directoryObject
+    this.#meta.parent = parentObject
 
     Object.freeze(this.#meta)
   }
@@ -145,7 +145,7 @@ export default class FileObject extends FS {
       extension: this.extension,
       isFile: this.isFile,
       isDirectory: this.isDirectory,
-      directory: this.directory ? this.directory.path : null
+      parent: this.parent ? this.parent.path : null
     }
   }
 
@@ -253,8 +253,8 @@ export default class FileObject extends FS {
    *
    * @returns {DirectoryObject} The parent directory object
    */
-  get directory() {
-    return this.#meta.directory
+  get parent() {
+    return this.#meta.parent
   }
 
   /**
@@ -411,11 +411,11 @@ export default class FileObject extends FS {
     if(!this.url)
       throw Sass.new("No URL in file")
 
-    if(await this.directory.exists)
+    if(await this.parent.exists)
       await fs.writeFile(this.url, content, encoding)
 
     else
-      throw Sass.new(`Invalid directory, ${this.directory.url.href}`)
+      throw Sass.new(`Invalid directory, ${this.parent.url.href}`)
   }
 
   /**
@@ -438,8 +438,8 @@ export default class FileObject extends FS {
     if(!this.url)
       throw Sass.new("No URL in file")
 
-    const exists = await this.directory.exists
-    Valid.assert(exists, `Invalid directory, ${this.directory.url.href}`)
+    const exists = await this.parent.exists
+    Valid.assert(exists, `Invalid directory, ${this.parent.url.href}`)
 
     Valid.assert(Data.isBinary(data), "Data must be binary (ArrayBuffer, TypedArray, Blob, or Buffer)")
 

package/src/lib/Glog.js

@@ -33,6 +33,15 @@ export const loggerColours = {
   reset: "{/}",      // Reset
 }
 
+// Symbol alternatives for tags
+export const logSymbols = {
+  debug: "?",
+  info: "i",
+  warn: "!",
+  error: "✗",
+  success: "✓"
+}
+
 // Set up convenient aliases for common log colors
 c.alias.set("debug", "{F033}")
 c.alias.set("info", "{F036}")
@@ -50,6 +59,7 @@ class Glog {
   static colors = null
   static stackTrace = false
   static name = ""
+  static tagsAsStrings = false
 
   // Instance properties (for configured loggers)
   #logLevel = 0
@@ -57,6 +67,8 @@ class Glog {
   #colors = null
   #stackTrace = false
   #name = ""
+  #tagsAsStrings = false
+  #displayName = true
   #vscodeError = null
   #vscodeWarn = null
   #vscodeInfo = null
@@ -87,6 +99,8 @@ class Glog {
     this.#logPrefix = options.prefix ?? this.#logPrefix
     this.#colors = options.colors ?? this.#colors
     this.#stackTrace = options.stackTrace ?? this.#stackTrace
+    this.#tagsAsStrings = options.tagsAsStrings ?? this.#tagsAsStrings
+    this.#displayName = options.displayName ?? this.#displayName
 
     return this
   }
@@ -123,6 +137,12 @@ class Glog {
     return this
   }
 
+  static withTagsAsStrings(enabled = false) {
+    this.tagsAsStrings = enabled
+
+    return this
+  }
+
   // === FLUENT INSTANCE CREATION ===
 
   static create(options = {}) {
@@ -159,6 +179,18 @@ class Glog {
     return this
   }
 
+  withTagsAsStrings(enabled = false) {
+    this.#tagsAsStrings = enabled
+
+    return this
+  }
+
+  noDisplayName() {
+    this.#displayName = false
+
+    return this
+  }
+
   // === UTILITY METHODS ===
 
   get name() {
@@ -182,19 +214,28 @@ class Glog {
   #compose(level, message, debugLevel = 0) {
     const colors = this.#colors || Glog.colors || loggerColours
     const name = this.#name || Glog.name || "Log"
-    const tag = Util.capitalize(level)
+    const useStrings = this.#tagsAsStrings || Glog.tagsAsStrings
+    const showName = this.#displayName
+    const tag = useStrings ? Util.capitalize(level) : logSymbols[level]
+    const namePrefix = showName ? `[${name}] ` : ""
 
     if(!colors) {
-      return `[${name}] ${tag}: ${message}`
+      return useStrings
+        ? `${namePrefix}${tag}: ${message}`
+        : `${namePrefix}${tag} ${message}`
     }
 
     if(level === "debug") {
       const colorCode = colors[level][debugLevel] || colors[level][0]
 
-      return c`[${name}] ${colorCode}${tag}{/}: ${message}`
+      return useStrings
+        ? c`${namePrefix}${colorCode}${tag}{/}: ${message}`
+        : c`${namePrefix}${colorCode}${tag}{/} ${message}`
     }
 
-    return c`[${name}] ${colors[level]}${tag}{/}: ${message}`
+    return useStrings
+      ? c`${namePrefix}${colors[level]}${tag}{/}: ${message}`
+      : c`${namePrefix}${colors[level]}${tag}{/} ${message}`
   }
 
   // Stack trace functionality - simplified for now
@@ -342,7 +383,16 @@ class Glog {
    * @param {...unknown} args - Additional arguments
    */
   success(message, ...args) {
-    Term.log(c`[${this.#name || Glog.name || "Log"}] {success}Success{/}: ${message}`, ...args)
+    const name = this.#name || Glog.name || "Log"
+    const useStrings = this.#tagsAsStrings || Glog.tagsAsStrings
+    const showName = this.#displayName
+    const tag = useStrings ? "Success" : logSymbols.success
+    const namePrefix = showName ? `[${name}] ` : ""
+    const formatted = useStrings
+      ? c`${namePrefix}{success}${tag}{/}: ${message}`
+      : c`${namePrefix}{success}${tag}{/} ${message}`
+
+    Term.log(formatted, ...args)
   }
 
   /**
@@ -352,7 +402,143 @@ class Glog {
    * @param {...unknown} args - Additional arguments to log
    */
   static success(message, ...args) {
-    Term.log(c`[${this.name || "Log"}] {success}Success{/}: ${message}`, ...args)
+    const name = this.name || "Log"
+    const useStrings = this.tagsAsStrings
+    const tag = useStrings ? "Success" : logSymbols.success
+    const formatted = useStrings
+      ? c`[${name}] {success}${tag}{/}: ${message}`
+      : c`[${name}] {success}${tag}{/} ${message}`
+
+    Term.log(formatted, ...args)
+  }
+
+  /**
+   * Static group method - start a console group for indented output
+   *
+   * @param {...unknown} args - Optional group label
+   */
+  static group(...args) {
+    const name = this.name || "Log"
+    const label = args.length > 0 ? ` ${args.join(" ")}` : ""
+
+    Term.group(`[${name}]${label}`)
+  }
+
+  /**
+   * Static groupEnd method - end the current console group
+   */
+  static groupEnd() {
+    Term.groupEnd()
+  }
+
+  /**
+   * Static groupDebug - start a debug-tagged group
+   *
+   * @param {string} message - Group label
+   * @param {number} [level=1] - Debug level
+   */
+  static groupDebug(message, level = 1) {
+    const colors = this.colors || loggerColours
+    const name = this.name || "Log"
+    const useStrings = this.tagsAsStrings
+    const tag = useStrings ? "Debug" : logSymbols.debug
+    const colorCode = colors.debug[level] || colors.debug[0]
+    const label = useStrings
+      ? c`[${name}] ${colorCode}${tag}{/}: ${message}`
+      : c`[${name}] ${colorCode}${tag}{/} ${message}`
+
+    Term.group(label)
+  }
+
+  /**
+   * Static groupInfo - start an info-tagged group
+   *
+   * @param {string} message - Group label
+   */
+  static groupInfo(message) {
+    const colors = this.colors || loggerColours
+    const name = this.name || "Log"
+    const useStrings = this.tagsAsStrings
+    const tag = useStrings ? "Info" : logSymbols.info
+    const label = useStrings
+      ? c`[${name}] ${colors.info}${tag}{/}: ${message}`
+      : c`[${name}] ${colors.info}${tag}{/} ${message}`
+
+    Term.group(label)
+  }
+
+  /**
+   * Static groupSuccess - start a success-tagged group
+   *
+   * @param {string} message - Group label
+   */
+  static groupSuccess(message) {
+    const name = this.name || "Log"
+    const useStrings = this.tagsAsStrings
+    const tag = useStrings ? "Success" : logSymbols.success
+    const label = useStrings
+      ? c`[${name}] {success}${tag}{/}: ${message}`
+      : c`[${name}] {success}${tag}{/} ${message}`
+
+    Term.group(label)
+  }
+
+  /**
+   * Start a console group for indented output
+   *
+   * @param {...unknown} args - Optional group label
+   */
+  group(...args) {
+    const name = this.#name || Glog.name || "Log"
+    const showName = this.#displayName
+    const label = args.length > 0 ? ` ${args.join(" ")}` : ""
+    const output = showName ? `[${name}]${label}` : label.trim()
+
+    Term.group(output)
+  }
+
+  /**
+   * End the current console group
+   */
+  groupEnd() {
+    Term.groupEnd()
+  }
+
+  /**
+   * Start a debug-tagged group
+   *
+   * @param {string} message - Group label
+   * @param {number} [level=1] - Debug level
+   */
+  groupDebug(message, level = 1) {
+    Term.group(this.#compose("debug", message, level))
+  }
+
+  /**
+   * Start an info-tagged group
+   *
+   * @param {string} message - Group label
+   */
+  groupInfo(message) {
+    Term.group(this.#compose("info", message))
+  }
+
+  /**
+   * Start a success-tagged group
+   *
+   * @param {string} message - Group label
+   */
+  groupSuccess(message) {
+    const name = this.#name || Glog.name || "Log"
+    const useStrings = this.#tagsAsStrings || Glog.tagsAsStrings
+    const showName = this.#displayName
+    const tag = useStrings ? "Success" : logSymbols.success
+    const namePrefix = showName ? `[${name}] ` : ""
+    const label = useStrings
+      ? c`${namePrefix}{success}${tag}{/}: ${message}`
+      : c`${namePrefix}{success}${tag}{/} ${message}`
+
+    Term.group(label)
   }
 
   /**
@@ -434,6 +620,44 @@ class Glog {
   get colours() {
     return c
   }
+
+  /**
+   * Get a raw logger that outputs without name/tag formatting
+   *
+   * @returns {object} Raw logger interface
+   */
+  get raw() {
+    return {
+      debug: (message, ...args) => Term.debug(message, ...args),
+      info: (message, ...args) => Term.info(message, ...args),
+      warn: (message, ...args) => Term.warn(message, ...args),
+      error: (message, ...args) => Term.error(message, ...args),
+      log: (...args) => Term.log(...args),
+      success: (message, ...args) => Term.log(message, ...args),
+      table: (data, options) => Term.table(data, options || {}),
+      group: (...args) => Term.group(...args),
+      groupEnd: () => Term.groupEnd()
+    }
+  }
+
+  /**
+   * Static raw logger that outputs without name/tag formatting
+   *
+   * @returns {object} Raw logger interface
+   */
+  static get raw() {
+    return {
+      debug: (message, ...args) => Term.debug(message, ...args),
+      info: (message, ...args) => Term.info(message, ...args),
+      warn: (message, ...args) => Term.warn(message, ...args),
+      error: (message, ...args) => Term.error(message, ...args),
+      log: (...args) => Term.log(...args),
+      success: (message, ...args) => Term.log(message, ...args),
+      table: (data, options) => Term.table(data, options || {}),
+      group: (...args) => Term.group(...args),
+      groupEnd: () => Term.groupEnd()
+    }
+  }
 }
 
 // Wrap in proxy for dual usage

package/src/types/lib/CappedDirectoryObject.d.ts

@@ -38,6 +38,12 @@ export default class CappedDirectoryObject extends DirectoryObject {
      * @returns {boolean} Always true for CappedDirectoryObject instances
      */
     get capped(): boolean;
+    /**
+     * Returns a generator that walks up to the cap.
+     *
+     * @returns {Generator<DirectoryObject>} Generator yielding parent directories
+     */
+    get walkUp(): Generator<DirectoryObject>;
     /**
      * Creates a new CappedDirectoryObject by extending this directory's path.
      *

package/src/types/lib/CappedDirectoryObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CappedDirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/CappedDirectoryObject.js"],"names":[],"mappings":"AAiBA;;;;;;;;GAQG;AACH;IAGE;;;;;;;;;;;;;;;;OAgBG;IACH,kBAXW,MAAM,OAAC,OACP,MAAM,WACN,qBAAqB,OAAC,cACtB,OAAO,EAkFjB;IAqBD;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,sBAVW,MAAM,GACJ,qBAAqB,CA0BjC;;CA6CF;4BA/N2B,sBAAsB"}
+{"version":3,"file":"CappedDirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/CappedDirectoryObject.js"],"names":[],"mappings":"AAiBA;;;;;;;;GAQG;AACH;IAGE;;;;;;;;;;;;;;;;OAgBG;IACH,kBAXW,MAAM,OAAC,OACP,MAAM,WACN,qBAAqB,OAAC,cACtB,OAAO,EAkFjB;IAqBD;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IA8DD;;;;OAIG;IACH,cAFa,SAAS,CAAC,eAAe,CAAC,CAItC;IAED;;;;;;;;;;;;;;OAcG;IACH,sBAVW,MAAM,GACJ,qBAAqB,CA0BjC;;CA6CF;4BApS2B,sBAAsB"}

package/src/types/lib/DirectoryObject.d.ts

@@ -21,6 +21,7 @@
  * @property {boolean} temporary - Whether this is marked as a temporary directory
  * @property {boolean} isFile - Always false (this is a directory)
  * @property {boolean} isDirectory - Always true
+ * @property {DirectoryObject|null} parent - The parent directory (null if root)
  * @property {Promise<boolean>} exists - Whether the directory exists (async getter)
  * @property {Generator<DirectoryObject>} walkUp - Generator yielding parent directories up to root
  *
@@ -124,6 +125,20 @@ export default class DirectoryObject extends FS {
      * @returns {boolean} True if this is a temporary directory, false otherwise
      */
     get temporary(): boolean;
+    /**
+     * Returns the parent directory of this directory.
+     * Returns null if this directory is the root directory.
+     * Computed lazily on first access and cached.
+     *
+     * @returns {DirectoryObject|null} The parent directory or null if root
+     * @example
+     * const dir = new DirectoryObject('/path/to/directory')
+     * console.log(dir.parent.path) // '/path/to'
+     *
+     * const root = new DirectoryObject('/')
+     * console.log(root.parent) // null
+     */
+    get parent(): DirectoryObject | null;
     /**
      * Recursively removes a temporary directory and all its contents.
      *

package/src/types/lib/DirectoryObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/DirectoryObject.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH;uBA4Fe,MAAM;IAjEnB;;;;;OAKG;IACH,yCAFW,OAAO,EA6BjB;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAalB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,aALa,KAAK,CAAC,MAAM,CAAC,CAOzB;IAED;;;;OAIG;IACH,iBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,UATa,OAAO,CAAC,IAAI,CAAC,CA0BzB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAiBD;;;;;;;;;;;;;;;OAeG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CAoCpF;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAqBzB;IA8BD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,MAAM,CAclB;IAED;;;;;;;;;;;;;;OAcG;IACH,UARa,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,sBAdW,MAAM,GACJ,eAAe,CAoB3B;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAbW,MAAM,GACJ,UAAU,CAmBtB;;CACF;eA9hBc,SAAS;uBACD,iBAAiB"}
+{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/DirectoryObject.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;uBAqGe,MAAM;IAlEnB;;;;;OAKG;IACH,yCAFW,OAAO,EA6BjB;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAclB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,aALa,KAAK,CAAC,MAAM,CAAC,CAOzB;IAED;;;;OAIG;IACH,iBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;OAYG;IACH,cARa,eAAe,GAAC,IAAI,CAwBhC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,UATa,OAAO,CAAC,IAAI,CAAC,CA0BzB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAiBD;;;;;;;;;;;;;;;OAeG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CAoCpF;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAqBzB;IA8BD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,MAAM,CAclB;IAED;;;;;;;;;;;;;;OAcG;IACH,UARa,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,sBAdW,MAAM,GACJ,eAAe,CAoB3B;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAbW,MAAM,GACJ,UAAU,CAmBtB;;CACF;eAvkBc,SAAS;uBACD,iBAAiB"}

package/src/types/lib/FileObject.d.ts

@@ -10,7 +10,7 @@
  * @property {string} extension - The file extension
  * @property {boolean} isFile - Always true for files
  * @property {boolean} isDirectory - Always false for files
- * @property {DirectoryObject} directory - The parent directory object
+ * @property {DirectoryObject} parent - The parent directory object
  * @property {Promise<boolean>} exists - Whether the file exists (async)
  */
 export default class FileObject extends FS {
@@ -28,9 +28,9 @@ export default class FileObject extends FS {
      * Constructs a FileObject instance.
      *
      * @param {string | FileObject} fileName - The file path or FileObject
-     * @param {DirectoryObject|string|null} [directory] - The parent directory (object or string)
+     * @param {DirectoryObject|string|null} [parent] - The parent directory (object or string)
      */
-    constructor(fileName: string | FileObject, directory?: DirectoryObject | string | null);
+    constructor(fileName: string | FileObject, parent?: DirectoryObject | string | null);
     /**
      * Returns a JSON representation of the FileObject.
      *
@@ -106,7 +106,7 @@ export default class FileObject extends FS {
      *
      * @returns {DirectoryObject} The parent directory object
      */
-    get directory(): DirectoryObject;
+    get parent(): DirectoryObject;
     /**
      * Check if a file can be read. Returns true if the file can be read, false
      *

package/src/types/lib/FileObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileObject.d.ts","sourceRoot":"","sources":["../../lib/FileObject.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;GAcG;AAEH;uBAuHe,MAAM;IAtHnB;;;;;OAKG;IACH,yBAFU;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC,CAAA;KAAC,CAO1D;IA2BF;;;;;OAKG;IACH,sBAHW,MAAM,GAAG,UAAU,cACnB,eAAe,GAAC,MAAM,GAAC,IAAI,EA2CrC;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAclB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IACD;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAFa,eAAe,CAI3B;IAED;;;;OAIG;IACH,WAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAED;;;;OAIG;IACH,YAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAiBD;;;;OAIG;IACH,QAFa,OAAO,CAAC,MAAM,OAAC,CAAC,CAU5B;IAED;;;;;OAKG;IACH,YAFa,OAAO,CAAC,IAAI,OAAC,CAAC,CAU1B;IAsBD;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;;;OAWG;IACH,cARa,OAAO,CAAC,MAAM,CAAC,CAkB3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAXW,WAAW,GAAC,IAAI,GAAC,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAXW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAkC5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;OASG;IACH,UAPa,OAAO,CAAC,IAAI,CAAC,CAiBzB;;CACF;eAtgBc,SAAS;4BADI,sBAAsB;kBARhC,OAAO;iBAIR,MAAM"}
+{"version":3,"file":"FileObject.d.ts","sourceRoot":"","sources":["../../lib/FileObject.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;GAcG;AAEH;uBAuHe,MAAM;IAtHnB;;;;;OAKG;IACH,yBAFU;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC,CAAA;KAAC,CAO1D;IA2BF;;;;;OAKG;IACH,sBAHW,MAAM,GAAG,UAAU,WACnB,eAAe,GAAC,MAAM,GAAC,IAAI,EA2CrC;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAclB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IACD;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,cAFa,eAAe,CAI3B;IAED;;;;OAIG;IACH,WAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAED;;;;OAIG;IACH,YAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAiBD;;;;OAIG;IACH,QAFa,OAAO,CAAC,MAAM,OAAC,CAAC,CAU5B;IAED;;;;;OAKG;IACH,YAFa,OAAO,CAAC,IAAI,OAAC,CAAC,CAU1B;IAsBD;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;;;OAWG;IACH,cARa,OAAO,CAAC,MAAM,CAAC,CAkB3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAXW,WAAW,GAAC,IAAI,GAAC,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAXW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAkC5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;OASG;IACH,UAPa,OAAO,CAAC,IAAI,CAAC,CAiBzB;;CACF;eAtgBc,SAAS;4BADI,sBAAsB;kBARhC,OAAO;iBAIR,MAAM"}

package/src/types/lib/Glog.d.ts

@@ -5,6 +5,17 @@ export namespace loggerColours {
     let error: string;
     let reset: string;
 }
+export namespace logSymbols {
+    let debug_1: string;
+    export { debug_1 as debug };
+    let info_1: string;
+    export { info_1 as info };
+    let warn_1: string;
+    export { warn_1 as warn };
+    let error_1: string;
+    export { error_1 as error };
+    export let success: string;
+}
 declare const _default: typeof Glog;
 export default _default;
 declare class Glog {
@@ -13,6 +24,7 @@ declare class Glog {
     static colors: any;
     static stackTrace: boolean;
     static name: string;
+    static tagsAsStrings: boolean;
     static setLogPrefix(prefix: any): typeof Glog;
     static setLogLevel(level: any): typeof Glog;
     static withName(name: any): typeof Glog;
@@ -24,6 +36,7 @@ declare class Glog {
         reset: string;
     }): typeof Glog;
     static withStackTrace(enabled?: boolean): typeof Glog;
+    static withTagsAsStrings(enabled?: boolean): typeof Glog;
     static create(options?: {}): Glog;
     static execute(...args: any[]): void;
     /**
@@ -40,6 +53,35 @@ declare class Glog {
      * @param {...unknown} args - Additional arguments to log
      */
     static success(message: string, ...args: unknown[]): void;
+    /**
+     * Static group method - start a console group for indented output
+     *
+     * @param {...unknown} args - Optional group label
+     */
+    static group(...args: unknown[]): void;
+    /**
+     * Static groupEnd method - end the current console group
+     */
+    static groupEnd(): void;
+    /**
+     * Static groupDebug - start a debug-tagged group
+     *
+     * @param {string} message - Group label
+     * @param {number} [level=1] - Debug level
+     */
+    static groupDebug(message: string, level?: number): void;
+    /**
+     * Static groupInfo - start an info-tagged group
+     *
+     * @param {string} message - Group label
+     */
+    static groupInfo(message: string): void;
+    /**
+     * Static groupSuccess - start a success-tagged group
+     *
+     * @param {string} message - Group label
+     */
+    static groupSuccess(message: string): void;
     /**
      * Static table method
      *
@@ -63,6 +105,12 @@ declare class Glog {
      * @returns {Glog} The Glog class for chaining.
      */
     static setAlias(alias: string, colorCode: string): Glog;
+    /**
+     * Static raw logger that outputs without name/tag formatting
+     *
+     * @returns {object} Raw logger interface
+     */
+    static get raw(): object;
     constructor(options?: {});
     setOptions(options: any): this;
     withName(name: any): this;
@@ -76,6 +124,8 @@ declare class Glog {
         reset: string;
     }): this;
     withStackTrace(enabled?: boolean): this;
+    withTagsAsStrings(enabled?: boolean): this;
+    noDisplayName(): this;
     get name(): string;
     get debugLevel(): number;
     get options(): {
@@ -117,6 +167,35 @@ declare class Glog {
      * @param {...unknown} args - Additional arguments
      */
     success(message: string, ...args: unknown[]): void;
+    /**
+     * Start a console group for indented output
+     *
+     * @param {...unknown} args - Optional group label
+     */
+    group(...args: unknown[]): void;
+    /**
+     * End the current console group
+     */
+    groupEnd(): void;
+    /**
+     * Start a debug-tagged group
+     *
+     * @param {string} message - Group label
+     * @param {number} [level=1] - Debug level
+     */
+    groupDebug(message: string, level?: number): void;
+    /**
+     * Start an info-tagged group
+     *
+     * @param {string} message - Group label
+     */
+    groupInfo(message: string): void;
+    /**
+     * Start a success-tagged group
+     *
+     * @param {string} message - Group label
+     */
+    groupSuccess(message: string): void;
     /**
      * Display tabular data as a table
      *
@@ -138,6 +217,12 @@ declare class Glog {
      * @returns {import('@gesslar/colours')} The colours template function from \@gesslar/colours
      */
     get colours(): typeof import("@gesslar/colours");
+    /**
+     * Get a raw logger that outputs without name/tag formatting
+     *
+     * @returns {object} Raw logger interface
+     */
+    get raw(): object;
     #private;
 }
 //# sourceMappingURL=Glog.d.ts.map

package/src/types/lib/Glog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Glog.d.ts","sourceRoot":"","sources":["../../lib/Glog.js"],"names":[],"mappings":";;;;;;;;;AA6CA;IAEE,wBAAmB;IACnB,yBAAqB;IACrB,mBAAoB;IACpB,2BAAyB;IACzB,oBAAgB;IA4ChB,8CAIC;IAED,4CAIC;IAED,wCAIC;IAED;;;;;;oBAIC;IAED,sDAIC;IAID,kCAEC;IAwJD,qCAoBC;IAuBD;;;;;OAKG;IACH,yBAHW,KAAK,CAAC,MAAM,CAAC,aACV,OAAO,EAAA,QAOpB;IAYD;;;;;OAKG;IACH,wBAHW,MAAM,WACH,OAAO,EAAA,QAIpB;IA+BD;;;;;;;;;OASG;IACH,mBAPW,MAAM,QAAQ,mBACd,MAAM,GAAG,MAAM,YAEvB;QAAgC,UAAU,GAAlC,KAAK,CAAC,MAAM,CAAC;QACK,UAAU,GAA5B,OAAO;QACW,aAAa,GAA/B,OAAO;KACjB,QAkBA;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,aACN,MAAM,GACJ,IAAI,CAMhB;IA3WD,0BAgBC;IAID,+BAQC;IAwCD,0BAIC;IAED,+BAIC;IAED,8BAIC;IAED;;;;;;aAIC;IAED,wCAIC;IAID,mBAEC;IAED,yBAEC;IAED;;;;;;MAQC;IAqBD,8BAGC;IAED,wBAQC;IA8BD;;;;;;;;;OASG;IACH,eALW,MAAM,UACN,MAAM,UACH,OAAO,EAAA,QAapB;IAED,wCAGC;IAED,wCAGC;IAED,yCAGC;IA0BD,8BAEC;IAID;;;;;;OAMG;IACH,kBAJW,KAAK,CAAC,MAAM,CAAC,aACV,OAAO,EAAA,QAQpB;IAeD;;;;;OAKG;IACH,iBAHW,MAAM,WACH,OAAO,EAAA,QAIpB;IAYD;;;;;;;;;OASG;IACH,YAPW,MAAM,QAAQ,mBACd,MAAM,GAAG,MAAM,YAEvB;QAAgC,UAAU,GAAlC,KAAK,CAAC,MAAM,CAAC;QACK,UAAU,GAA5B,OAAO;QACW,aAAa,GAA/B,OAAO;KACjB,QAkBA;IA4CD;;;;OAIG;IACH,iDAEC;;CACF"}
+{"version":3,"file":"Glog.d.ts","sourceRoot":"","sources":["../../lib/Glog.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAsDA;IAEE,wBAAmB;IACnB,yBAAqB;IACrB,mBAAoB;IACpB,2BAAyB;IACzB,oBAAgB;IAChB,8BAA4B;IAgD5B,8CAIC;IAED,4CAIC;IAED,wCAIC;IAED;;;;;;oBAIC;IAED,sDAIC;IAED,yDAIC;IAID,kCAEC;IA6KD,qCAoBC;IAuBD;;;;;OAKG;IACH,yBAHW,KAAK,CAAC,MAAM,CAAC,aACV,OAAO,EAAA,QAOpB;IAqBD;;;;;OAKG;IACH,wBAHW,MAAM,WACH,OAAO,EAAA,QAWpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAOpB;IAED;;OAEG;IACH,wBAEC;IAED;;;;;OAKG;IACH,2BAHW,MAAM,UACN,MAAM,QAahB;IAED;;;;OAIG;IACH,0BAFW,MAAM,QAYhB;IAED;;;;OAIG;IACH,6BAFW,MAAM,QAWhB;IAyFD;;;;;;;;;OASG;IACH,mBAPW,MAAM,QAAQ,mBACd,MAAM,GAAG,MAAM,YAEvB;QAAgC,UAAU,GAAlC,KAAK,CAAC,MAAM,CAAC;QACK,UAAU,GAA5B,OAAO;QACW,aAAa,GAA/B,OAAO;KACjB,QAkBA;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,aACN,MAAM,GACJ,IAAI,CAMhB;IA8BD;;;;OAIG;IACH,kBAFa,MAAM,CAclB;IAxkBD,0BAgBC;IAID,+BAUC;IA8CD,0BAIC;IAED,+BAIC;IAED,8BAIC;IAED;;;;;;aAIC;IAED,wCAIC;IAED,2CAIC;IAED,sBAIC;IAID,mBAEC;IAED,yBAEC;IAED;;;;;;MAQC;IA8BD,8BAGC;IAED,wBAQC;IA8BD;;;;;;;;;OASG;IACH,eALW,MAAM,UACN,MAAM,UACH,OAAO,EAAA,QAapB;IAED,wCAGC;IAED,wCAGC;IAED,yCAGC;IA0BD,8BAEC;IAID;;;;;;OAMG;IACH,kBAJW,KAAK,CAAC,MAAM,CAAC,aACV,OAAO,EAAA,QAQpB;IAeD;;;;;OAKG;IACH,iBAHW,MAAM,WACH,OAAO,EAAA,QAapB;IA0FD;;;;OAIG;IACH,eAFc,OAAO,EAAA,QASpB;IAED;;OAEG;IACH,iBAEC;IAED;;;;;OAKG;IACH,oBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAFW,MAAM,QAahB;IAED;;;;;;;;;OASG;IACH,YAPW,MAAM,QAAQ,mBACd,MAAM,GAAG,MAAM,YAEvB;QAAgC,UAAU,GAAlC,KAAK,CAAC,MAAM,CAAC;QACK,UAAU,GAA5B,OAAO;QACW,aAAa,GAA/B,OAAO;KACjB,QAkBA;IA4CD;;;;OAIG;IACH,iDAEC;IAED;;;;OAIG;IACH,WAFa,MAAM,CAclB;;CAoBF"}