@medyll/idae-be 0.81.0 → 0.82.0

package/dist/be.d.ts

@@ -57,6 +57,12 @@ export declare class Be {
     private textHandler;
     appendText: TextHandler['append'];
     prependText: TextHandler['prepend'];
+    updateText: TextHandler['update'];
+    replaceText: TextHandler['replace'];
+    removeText: TextHandler['remove'];
+    clearText: TextHandler['clear'];
+    normalizeText: TextHandler['normalize'];
+    wrapText: TextHandler['wrap'];
     events: (actions: EventHandlerHandle) => Be;
     private eventHandler;
     on: EventsHandler['on'];

package/dist/be.js

@@ -65,6 +65,12 @@ export class Be {
     textHandler;
     appendText;
     prependText;
+    updateText;
+    replaceText;
+    removeText;
+    clearText;
+    normalizeText;
+    wrapText;
     // events
     events;
     eventHandler;

package/dist/modules/classes.d.ts

@@ -32,6 +32,8 @@ export declare class ClassesHandler implements CommonHandler<ClassesHandler, Cla
     private beElement;
     static methods: classesMethods[];
     constructor(beElement: Be);
+    methods: string[] | keyof ClassesHandler;
+    valueOf(): string;
     handle(actions: ClassHandlerHandlerHandle): Be;
     add(className: string | string[]): Be;
     /**

package/dist/modules/classes.js

@@ -1,4 +1,3 @@
-import { BeUtils } from '../utils.js';
 import { Be } from '../be.js';
 var classesMethods;
 (function (classesMethods) {
@@ -16,6 +15,10 @@ export class ClassesHandler {
     constructor(beElement) {
         this.beElement = beElement;
     }
+    methods = ClassesHandler.methods;
+    valueOf() {
+        return `[ClassesHandler: methods=${this.methods}]`;
+    }
     handle(actions) {
         if (!actions)
             return this.beElement;
@@ -26,25 +29,6 @@ export class ClassesHandler {
                     break;
             }
         });
-        /* this.beElement.eachNode((el) => {
-            if (actions.replace) {
-                let replacements: [string, string][];
-                if (typeof actions.replace === 'string') {
-                    replacements = actions.replace
-                        .split(';')
-                        .map((pair) => pair.trim().split(' ') as [string, string]);
-                } else if (Array.isArray(actions.replace) && actions.replace.every(Array.isArray)) {
-                    replacements = actions.replace as [string, string][];
-                } else {
-                    replacements = [actions.replace.split(' ') as [string, string]];
-                }
-                replacements.forEach(([oldClass, newClass]) => {
-                    if (oldClass && newClass) {
-                        el.classList.replace(oldClass, newClass);
-                    }
-                });
-            }
-        }); */
         return this.beElement;
     }
     add(className) {

package/dist/modules/data.d.ts

@@ -6,19 +6,62 @@ declare enum dataMethods {
     delete = "delete",
     getKey = "getKey"
 }
+/**
+ * Type definition for DataHandler actions.
+ */
 export type DataHandlerHandle = {
+    get: (keyOrObject: string | Record<string, string>, value?: string) => Be;
     set: (keyOrObject: string | Record<string, string>, value?: string) => Be;
     delete: (keyOrObject: string | Record<string, string>, value?: string) => Be;
+    getKey: (keyOrObject: string | Record<string, string>, value?: string) => Be;
 };
+/**
+ * Handles operations on `data-*` attributes for Be elements.
+ */
 export declare class DataHandler implements CommonHandler<DataHandler> {
     private beElement;
     static methods: dataMethods[];
+    /**
+     * Initializes the DataHandler with a Be element.
+     * @param element - The Be element to operate on.
+     */
     constructor(element: Be);
+    methods: string[] | keyof DataHandler;
+    /**
+     * Handles dynamic method calls for data operations.
+     * @param actions - The action to perform (e.g., set, get, delete).
+     * @returns The Be element for chaining.
+     */
     handle(actions: Partial<DataHandlerHandle>): Be;
+    /**
+     * Retrieves the value of a `data-*` attribute.
+     * @param key - The key of the `data-*` attribute to retrieve.
+     * @returns The value of the attribute, or `null` if not found.
+     */
     get(key: string): string | null;
+    /**
+     * Sets one or more `data-*` attributes.
+     * @param keyOrObject - A key-value pair or an object containing multiple key-value pairs.
+     * @param value - The value to set if a single key is provided.
+     * @returns The Be element for chaining.
+     */
     set(keyOrObject: string | Record<string, string>, value?: string): Be;
-    delete(keyOrObject: string | Record<string, string>, value?: string): Be;
+    /**
+     * Deletes one or more `data-*` attributes.
+     * @param keyOrObject - A key or an object containing multiple keys to delete.
+     * @returns The Be element for chaining.
+     */
+    delete(keyOrObject: string | Record<string, string>): Be;
+    /**
+     * Retrieves the value of a specific `data-*` attribute.
+     * @param key - The key of the `data-*` attribute to retrieve.
+     * @returns The value of the attribute, or `null` if not found.
+     */
     getKey(key: string | string[]): string | null;
+    /**
+     * Retrieves all `data-*` attributes as a DOMStringMap.
+     * @returns A DOMStringMap containing all `data-*` attributes, or `null` if not applicable.
+     */
     valueOf(): DOMStringMap | null;
 }
 export {};

package/dist/modules/data.js

@@ -7,14 +7,27 @@ var dataMethods;
     dataMethods["delete"] = "delete";
     dataMethods["getKey"] = "getKey";
 })(dataMethods || (dataMethods = {}));
+/**
+ * Handles operations on `data-*` attributes for Be elements.
+ */
 export class DataHandler {
     beElement;
     static methods = Object.values(dataMethods);
+    /**
+     * Initializes the DataHandler with a Be element.
+     * @param element - The Be element to operate on.
+     */
     constructor(element) {
         this.beElement = element;
     }
+    methods = DataHandler.methods;
+    /**
+     * Handles dynamic method calls for data operations.
+     * @param actions - The action to perform (e.g., set, get, delete).
+     * @returns The Be element for chaining.
+     */
     handle(actions) {
-        const { method, props } = BeUtils.resolveIndirection(DataHandler, actions);
+        const { method, props } = BeUtils.resolveIndirection(this, actions);
         switch (method) {
             case 'set':
             case 'delete':
@@ -23,12 +36,22 @@ export class DataHandler {
         }
         return this.beElement;
     }
+    /**
+     * Retrieves the value of a `data-*` attribute.
+     * @param key - The key of the `data-*` attribute to retrieve.
+     * @returns The value of the attribute, or `null` if not found.
+     */
     get(key) {
-        // if space in string
         if (this.beElement.isWhat !== 'element')
             return null;
         return this.beElement.inputNode.dataset[key] || null;
     }
+    /**
+     * Sets one or more `data-*` attributes.
+     * @param keyOrObject - A key-value pair or an object containing multiple key-value pairs.
+     * @param value - The value to set if a single key is provided.
+     * @returns The Be element for chaining.
+     */
     set(keyOrObject, value) {
         this.beElement.eachNode((el) => {
             if (typeof keyOrObject === 'string' && value !== undefined) {
@@ -42,25 +65,40 @@ export class DataHandler {
         });
         return this.beElement;
     }
-    delete(keyOrObject, value) {
+    /**
+     * Deletes one or more `data-*` attributes.
+     * @param keyOrObject - A key or an object containing multiple keys to delete.
+     * @returns The Be element for chaining.
+     */
+    delete(keyOrObject) {
         this.beElement.eachNode((el) => {
-            if (typeof keyOrObject === 'string' && value !== undefined) {
-                el.dataset[keyOrObject] = value;
+            if (typeof keyOrObject === 'string') {
+                // Deletes a single attribute
+                delete el.dataset[keyOrObject];
             }
             else if (typeof keyOrObject === 'object') {
-                Object.entries(keyOrObject).forEach(([key, val]) => {
+                // Deletes multiple attributes
+                Object.keys(keyOrObject).forEach((key) => {
                     delete el.dataset[key];
                 });
             }
         });
         return this.beElement;
     }
+    /**
+     * Retrieves the value of a specific `data-*` attribute.
+     * @param key - The key of the `data-*` attribute to retrieve.
+     * @returns The value of the attribute, or `null` if not found.
+     */
     getKey(key) {
-        // if spaces in string
         if (this.beElement.isWhat !== 'element')
             return null;
         return this.beElement.inputNode.dataset[key] || null;
     }
+    /**
+     * Retrieves all `data-*` attributes as a DOMStringMap.
+     * @returns A DOMStringMap containing all `data-*` attributes, or `null` if not applicable.
+     */
     valueOf() {
         if (this.beElement.isWhat !== 'element')
             return null;

package/dist/modules/dom.d.ts

@@ -70,6 +70,7 @@ export declare class DomHandler implements DomHandlerInterface, CommonHandler<Do
     private beElement;
     static methods: domMethods[];
     constructor(element: Be);
+    methods: string[] | keyof DomHandler;
     /**
      * Handles various DOM operations on the element(s).
      * @param actions An object specifying the DOM actions to perform.

package/dist/modules/dom.js

@@ -21,6 +21,7 @@ export class DomHandler {
     constructor(element) {
         this.beElement = element;
     }
+    methods = DomHandler.methods;
     /**
      * Handles various DOM operations on the element(s).
      * @param actions An object specifying the DOM actions to perform.

package/dist/modules/position.d.ts

@@ -23,6 +23,7 @@ export declare class PositionHandler implements CommonHandler<PositionHandler, P
     private beElement;
     static methods: positionMethods[];
     constructor(beElement: Be);
+    methods: string[] | keyof PositionHandler;
     handle(actions: PositionHandlerHandle): Be;
     /**
      * Clones the position of a source element to this element.

package/dist/modules/position.js

@@ -12,6 +12,7 @@ export class PositionHandler {
     constructor(beElement) {
         this.beElement = beElement;
     }
+    methods = PositionHandler.methods;
     handle(actions) {
         Object.entries(actions).forEach(([method, props]) => {
             switch (method) {
@@ -141,11 +142,8 @@ export class PositionHandler {
         const sourceRect = this.beElement.inputNode.getBoundingClientRect();
         const targetRect = targetEl.getBoundingClientRect();
         const { sourceAnchor, targetAnchor, offset = { x: 0, y: 0 } } = options;
-        let sourceX, sourceY, targetX, targetY;
-        // Calculate source anchor point
-        [sourceX, sourceY] = BeUtils.calculateAnchorPoint(sourceRect, sourceAnchor);
-        // Calculate target anchor point
-        [targetX, targetY] = BeUtils.calculateAnchorPoint(targetRect, targetAnchor);
+        const [sourceX, sourceY] = BeUtils.calculateAnchorPoint(sourceRect, sourceAnchor);
+        const [targetX, targetY] = BeUtils.calculateAnchorPoint(targetRect, targetAnchor);
         // Calculate final position
         const x = targetX - sourceX + offset.x;
         const y = targetY - sourceY + offset.y;

package/dist/modules/props.d.ts

@@ -17,7 +17,8 @@ export interface PropsHandlerHandle {
 export declare class PropsHandler implements CommonHandler<PropsHandler, PropsHandlerHandle> {
     private beElement;
     static methods: PropsMethods[];
-    constructor(element: Be);
+    constructor(beElement: Be);
+    methods: (keyof PropsHandler)[];
     handle(actions: PropsHandlerHandle): Be;
     get(name: string, callback?: HandlerCallBackFn): any;
     set(nameOrObject: string | Record<string, any>, value?: any, callback?: HandlerCallBackFn): Be;

package/dist/modules/props.js

@@ -9,9 +9,10 @@ var PropsMethods;
 export class PropsHandler {
     beElement;
     static methods = Object.values(PropsMethods);
-    constructor(element) {
-        this.beElement = element;
+    constructor(beElement) {
+        this.beElement = beElement;
     }
+    methods = PropsHandler.methods;
     handle(actions) {
         if (!actions)
             return this.beElement;

package/dist/modules/styles.d.ts

@@ -14,6 +14,8 @@ export type BeStylesHandlerMethods = keyof typeof beStyleMethods;
 export declare class StylesHandler implements CommonHandler<StylesHandler> {
     private beElement;
     constructor(beElement: Be);
+    methods: string[];
+    valueOf(): string;
     static methods: beStyleMethods[];
     handle(actions: BeStylesHandler): Be;
     private resolveIndirection;

package/dist/modules/styles.js

@@ -10,10 +10,14 @@ export class StylesHandler {
     constructor(beElement) {
         this.beElement = beElement;
     }
+    methods = Object.keys(beStyleMethods);
+    valueOf() {
+        return `[StylesHandler: ${this.methods.join(', ')}]`;
+    }
     static methods = Object.values(beStyleMethods);
     handle(actions) {
         const { method, args } = this.resolveIndirection(actions);
-        this.beElement.eachNode((el) => {
+        this.beElement.eachNode(() => {
             switch (method) {
                 case 'set':
                     if (typeof args === 'string') {
@@ -37,7 +41,7 @@ export class StylesHandler {
                     }
                     break;
                 case 'get':
-                    return this.get(args);
+                    this.get(args);
                     break;
                 case 'unset':
                     this.unset(args);
@@ -47,15 +51,16 @@ export class StylesHandler {
         return this.beElement;
     }
     resolveIndirection(actions) {
-        let method;
+        let method = 'get'; // Default to 'get' or any valid method
         let args;
         Object.keys(actions).forEach((action) => {
-            if (StylesHandler.methods.includes(action)) {
-                method = action;
-                args = actions[action];
+            const actionKey = action;
+            if (StylesHandler.methods.includes(actionKey)) {
+                method = actionKey;
+                args = actions[actionKey];
             }
         });
-        return { method, args };
+        return { method: method, args };
     }
     /**
      * setStyle Sets one or more CSS styles for the selected element(s), including CSS custom properties.
@@ -92,7 +97,9 @@ export class StylesHandler {
     get(key) {
         let css = null;
         this.beElement.eachNode((el) => {
+            // Prioritize inline styles
             css = el.style[key] || null;
+            // Fallback to computed styles if inline style is not set
             if (!css) {
                 const computedStyle = window.getComputedStyle(el);
                 css = computedStyle.getPropertyValue(key).trim();
@@ -109,9 +116,8 @@ export class StylesHandler {
     }
     applyStyle(property, value) {
         this.beElement.eachNode((el) => {
-            el.style[property] = value;
-            // el.style.setProperty(property, value);
-            // console.log(`Setting style ${property}: ${value}`);
+            const kebabProperty = toKebabCase(property);
+            el.style.setProperty(kebabProperty, value);
         });
     }
     getKey(key) {
@@ -122,3 +128,6 @@ export class StylesHandler {
         return value;
     }
 }
+function toKebabCase(property) {
+    return property.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}

package/dist/modules/text.d.ts

@@ -25,17 +25,17 @@ export declare class TextHandler implements CommonHandler<TextHandler> {
     private beElement;
     static methods: textMethods[];
     constructor(element: Be);
+    methods: string[] | keyof TextHandler;
     get text(): string | null;
     handle(actions: TextHandlerHandle): Be;
-    update(content: TextHandlerHandle['update'], callback?: HandlerCallBackFn): void;
-    updateText(content: TextHandlerHandle['updateText'], callback?: HandlerCallBackFn): void;
+    update(content: TextHandlerHandle['update'], callback?: HandlerCallBackFn): Be;
     append(content: TextHandlerHandle['append'], callback?: HandlerCallBackFn): Be;
-    prepend(content: TextHandlerHandle['prepend'], callback?: HandlerCallBackFn): void;
-    replace(content: TextHandlerHandle['replace'], callback?: HandlerCallBackFn): void;
-    remove(content: TextHandlerHandle['remove'], callback?: HandlerCallBackFn): void;
-    clear(content: TextHandlerHandle['clear'], callback?: HandlerCallBackFn): void;
-    normalize(content: TextHandlerHandle['normalize'], callback?: HandlerCallBackFn): void;
-    wrap(content: TextHandlerHandle['wrap'], callback?: HandlerCallBackFn): void;
+    prepend(content: TextHandlerHandle['prepend'], callback?: HandlerCallBackFn): Be;
+    replace(content: TextHandlerHandle['replace'], callback?: HandlerCallBackFn): Be;
+    remove(callback?: HandlerCallBackFn): Be;
+    clear(callback?: HandlerCallBackFn): Be;
+    normalize(callback?: HandlerCallBackFn): Be;
+    wrap(content: TextHandlerHandle['wrap'], callback?: HandlerCallBackFn): Be;
     valueOf(): string | null;
 }
 export {};

package/dist/modules/text.js

@@ -17,6 +17,7 @@ export class TextHandler {
     constructor(element) {
         this.beElement = element;
     }
+    methods = TextHandler.methods;
     get text() {
         if (this.beElement.isWhat !== 'element')
             return null;
@@ -24,29 +25,57 @@ export class TextHandler {
     }
     handle(actions) {
         this.beElement.eachNode((el) => {
-            const { method, props } = BeUtils.resolveIndirection(TextHandler, actions);
+            const { method, props } = BeUtils.resolveIndirection(new TextHandler(this.beElement), actions);
             switch (method) {
                 case 'update':
-                    el.innerText = props;
+                    if (typeof props === 'string') {
+                        el.innerText = props;
+                    }
                     break;
-                case 'prepend': // append to text content
-                    el.insertAdjacentHTML('beforebegin', props);
+                case 'prepend':
+                    if (typeof props === 'string') {
+                        el.insertAdjacentHTML('afterbegin', props);
+                    }
+                    else {
+                        throw new Error('Invalid props for prepend: must be a string.');
+                    }
                     break;
                 case 'append':
-                    el.insertAdjacentHTML('afterbegin', props);
+                    if (typeof props === 'string') {
+                        el.insertAdjacentHTML('beforeend', props);
+                    }
+                    else {
+                        throw new Error('Invalid props for append: must be a string.');
+                    }
                     break;
                 case 'replace':
-                    el.outerHTML = props;
+                    if (typeof props === 'string') {
+                        el.outerHTML = props;
+                    }
+                    else {
+                        throw new Error('Invalid props for replace: must be a string.');
+                    }
                     break;
                 case 'remove':
                     el.remove();
                     break;
                 case 'clear':
-                    el.outerHTML = '';
+                    el.innerHTML = '';
                     break;
                 case 'normalize':
                     el.normalize();
                     break;
+                case 'wrap':
+                    if (typeof props === 'string') {
+                        const wrapper = document.createElement('div');
+                        wrapper.innerHTML = props.trim();
+                        const parent = wrapper.firstElementChild;
+                        if (parent) {
+                            el.parentNode?.insertBefore(parent, el);
+                            parent.appendChild(el);
+                        }
+                    }
+                    break;
             }
             actions?.callback?.({
                 fragment: props,
@@ -57,31 +86,28 @@ export class TextHandler {
         return this.beElement;
     }
     update(content, callback) {
-        this.handle({ update: content, callback });
-    }
-    updateText(content, callback) {
-        this.handle({ updateText: content, callback });
+        return this.handle({ update: content, callback });
     }
     append(content, callback) {
         return this.handle({ append: content, callback });
     }
     prepend(content, callback) {
-        this.handle({ prepend: content, callback });
+        return this.handle({ prepend: content, callback });
     }
     replace(content, callback) {
-        this.handle({ replace: content, callback });
+        return this.handle({ replace: content, callback });
     }
-    remove(content, callback) {
-        this.handle({ remove: content, callback });
+    remove(callback) {
+        return this.handle({ remove: undefined, callback });
     }
-    clear(content, callback) {
-        this.handle({ clear: content, callback });
+    clear(callback) {
+        return this.handle({ clear: undefined, callback });
     }
-    normalize(content, callback) {
-        this.handle({ normalize: content, callback });
+    normalize(callback) {
+        return this.handle({ normalize: undefined, callback });
     }
     wrap(content, callback) {
-        this.handle({ wrap: content, callback });
+        return this.handle({ wrap: content, callback });
     }
     valueOf() {
         if (this.beElement.isWhat !== 'element')

package/dist/modules/timers.d.ts

@@ -15,10 +15,12 @@ export declare class TimersHandler implements CommonHandler<TimersHandler> {
     _timer: NodeJS.Timeout | null;
     _interval: NodeJS.Timeout | null;
     constructor(element: Be);
+    methods: string[] | keyof TimersHandler;
+    valueOf(): unknown;
     handle(actions: TimerHandlerHandle): Be;
     timeout(value: TimerHandlerHandle['timeout'], callback?: HandlerCallBackFn): Be;
     interval(value: TimerHandlerHandle['interval'], callback?: HandlerCallBackFn): Be;
-    clearTimeout(callback?: HandlerCallBackFn): void;
-    clearInterval(callback?: HandlerCallBackFn): void;
+    clearTimeout(callback?: HandlerCallBackFn): Be;
+    clearInterval(callback?: HandlerCallBackFn): Be;
 }
 export {};

package/dist/modules/timers.js

@@ -14,6 +14,14 @@ export class TimersHandler {
     constructor(element) {
         this.beElement = element;
     }
+    methods = TimersHandler.methods;
+    valueOf() {
+        return {
+            methods: this.methods,
+            timer: this._timer,
+            interval: this._interval
+        };
+    }
     handle(actions) {
         if (!actions)
             return this.beElement;
@@ -32,7 +40,15 @@ export class TimersHandler {
         return this.beElement;
     }
     timeout(value, callback) {
-        this.beElement.eachNode((el) => {
+        this.beElement.BeTimer = setTimeout(() => {
+            callback?.({
+                method: 'timeout',
+                fragment: this.beElement.BeTimer,
+                be: this.beElement,
+                root: this.beElement
+            });
+        }, value);
+        /* this.beElement.eachNode((el: HTMLElement) => {
             const aug = be(el);
             aug.BeTimer = setTimeout(() => {
                 callback?.({
@@ -42,43 +58,65 @@ export class TimersHandler {
                     root: this.beElement
                 });
             }, value);
-        });
+        }); */
         return this.beElement;
     }
     interval(value, callback) {
-        this.beElement.eachNode((el) => {
+        this.beElement.BeInterval = setInterval(() => {
+            callback?.({
+                method: 'interval',
+                fragment: this.beElement.BeInterval,
+                be: this.beElement,
+                root: this.beElement
+            });
+        }, value);
+        /* this.beElement.eachNode((el: HTMLElement) => {
             const aug = be(el);
-            aug.BeTimer = setInterval(() => {
+            aug.BeInterval = setInterval(() => {
                 callback?.({
                     method: 'interval',
-                    fragment: aug.BeTimer,
+                    fragment: aug.BeInterval,
                     be: be(el),
                     root: this.beElement
                 });
             }, value);
-        });
+        }); */
         return this.beElement;
     }
     clearTimeout(callback) {
-        this.beElement.eachNode((el) => {
-            clearTimeout(be(el).BeTimer);
-            callback?.({
-                method: 'clearTimeout',
-                fragment: be(el).BeTimer,
-                be: be(el),
-                root: this.beElement
-            });
+        clearTimeout(this.beElement?.BeTimer);
+        this.beElement.BeTimer = null;
+        /* this.beElement.eachNode((el: HTMLElement) => {
+            const aug = be(el);
+            if (aug.BeTimer !== null) {
+                clearTimeout(aug.BeTimer);
+                aug.BeTimer = null;
+            }
+        }); */
+        callback?.({
+            method: 'clearTimeout',
+            fragment: null,
+            be: this.beElement,
+            root: this.beElement
         });
+        return this.beElement;
     }
     clearInterval(callback) {
-        this.beElement.eachNode((el) => {
-            clearInterval(be(el).BeTimer);
-            callback?.({
-                method: 'clearInterval',
-                fragment: be(el).BeTimer,
-                be: be(el),
-                root: this.beElement
-            });
+        clearInterval(this.beElement?.BeInterval);
+        this.beElement.BeInterval = null;
+        /* this.beElement.eachNode((el: HTMLElement) => {
+            const aug = be(el);
+            if (aug.BeInterval !== null) {
+                clearInterval(aug.BeInterval);
+                aug.BeInterval = null;
+            }
+        }); */
+        callback?.({
+            method: 'clearInterval',
+            fragment: null,
+            be: this.beElement,
+            root: this.beElement
         });
+        return this.beElement;
     }
 }

package/dist/modules/walk.d.ts

@@ -101,6 +101,8 @@ export declare class WalkHandler implements WalkHandlerInterface, CommonHandler<
      * @param beElement - The Be element to operate on.
      */
     constructor(beElement: Be);
+    methods: string[];
+    valueOf(): unknown;
     /**
      * Handles multiple walk operations.
      * @param actions - The actions to perform.

package/dist/modules/walk.js

@@ -29,6 +29,10 @@ export class WalkHandler {
     constructor(beElement) {
         this.beElement = beElement;
     }
+    methods = WalkHandler.methods;
+    valueOf() {
+        return this.beElement;
+    }
     /**
      * Handles multiple walk operations.
      * @param actions - The actions to perform.
@@ -114,7 +118,6 @@ export class WalkHandler {
         this.beElement.eachNode((el) => {
             if (el.parentNode) {
                 const siblings = Array.from(el.parentNode.children).filter((child) => child !== el);
-                console.log('siblings found:', siblings); // Debug
                 ret.push(...siblings.filter((sibling) => !qy || sibling.matches(qy)));
             }
         });
@@ -188,7 +191,6 @@ export class WalkHandler {
         const ret = [];
         this.beElement.eachNode((el) => {
             const found = el.querySelector(qy);
-            console.log('find result:', found); // Debug
             if (found)
                 ret.push(found);
         });
@@ -231,7 +233,6 @@ export class WalkHandler {
                 const ret = [];
                 this.beElement.eachNode((el) => {
                     const result = this.selectWhile(el, method, qy);
-                    console.log(`methodize result for ${method}:`, typeof result, result); // Debug
                     if (result)
                         ret.push(...(Array.isArray(result) ? result : [result]));
                 });
@@ -245,7 +246,7 @@ export class WalkHandler {
                 return resultBe;
             }
             catch (e) {
-                console.error(`Error in methodize for ${method}:`, e); // Debug
+                console.error(`Error in methodize for ${method}:`, e);
             }
             return this.beElement;
         };

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@medyll/idae-be",
 	"scope": "@medyll",
-	"version": "0.81.0",
+	"version": "0.82.0",
 	"description": "A powerful DOM manipulation library with a callback-based approach for precise element targeting. Provides consistent chaining, comprehensive DOM traversal, event handling, style management, and more. Written in TypeScript for modern browsers.",
 	"scripts": {
 		"dev": "vite dev",