@medyll/idae-be 0.81.0 → 0.83.0

package/dist/be.d.ts

@@ -4,7 +4,6 @@ import type { IsWhat } from './types.js';
 import { type DataHandlerHandle, DataHandler } from './modules/data.js';
 import { EventsHandler, type EventHandlerHandle } from './modules/events.js';
 import { type ClassHandlerHandler, ClassesHandler } from './modules/classes.js';
-import { type PropsHandlerHandle } from './modules/props.js';
 import { DomHandler, type DomHandlerHandle } from './modules/dom.js';
 import { PositionHandler, type PositionHandlerHandle } from './modules/position.js';
 import { WalkHandler } from './modules/walk.js';
@@ -13,15 +12,13 @@ import { TimersHandler } from './modules/timers.js';
 export declare class Be {
     inputNode: HTMLElement | HTMLElement[] | string;
     isWhat: IsWhat;
-    BeTimer: NodeJS.Timeout | null;
-    BeInterval: NodeJS.Timeout | null;
+    timerOut: NodeJS.Timeout | null;
+    timerInterval: NodeJS.Timeout | null;
     styles: (actions: BeStylesHandler) => Be;
     private styleHandler;
     setStyle: StylesHandler['set'];
     getStyle: StylesHandler['get'];
     unsetStyle: StylesHandler['unset'];
-    props: (actions: PropsHandlerHandle) => Be;
-    private propHandler;
     data: (actions: DataHandlerHandle) => Be;
     private dataHandler;
     setData: DataHandler['set'];
@@ -57,6 +54,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

@@ -4,7 +4,6 @@ import { BeUtils } from './utils.js';
 import { DataHandler } from './modules/data.js';
 import { EventsHandler } from './modules/events.js';
 import { ClassesHandler } from './modules/classes.js';
-import { PropsHandler } from './modules/props.js';
 import { DomHandler } from './modules/dom.js';
 import { PositionHandler } from './modules/position.js';
 import { WalkHandler } from './modules/walk.js';
@@ -14,17 +13,14 @@ export class Be {
     inputNode;
     isWhat;
     //
-    BeTimer = null;
-    BeInterval = null;
+    timerOut = null;
+    timerInterval = null;
     // styles
     styles;
     styleHandler;
     setStyle;
     getStyle;
     unsetStyle;
-    // properties
-    props;
-    propHandler;
     // dataSet
     data;
     dataHandler;
@@ -65,6 +61,12 @@ export class Be {
     textHandler;
     appendText;
     prependText;
+    updateText;
+    replaceText;
+    removeText;
+    clearText;
+    normalizeText;
+    wrapText;
     // events
     events;
     eventHandler;
@@ -114,10 +116,6 @@ export class Be {
         this.styleHandler = new StylesHandler(this);
         this.styles = this.handle(this.styleHandler);
         this.attach(StylesHandler, 'Style');
-        // properties
-        this.propHandler = new PropsHandler(this);
-        this.props = this.handle(this.styleHandler);
-        this.attach(PropsHandler, 'Prop');
         // dataSet
         this.dataHandler = new DataHandler(this);
         this.data = this.handle(this.styleHandler);

package/dist/index.d.ts

@@ -5,7 +5,6 @@ export * from './modules/walk.js';
 export * from './modules/timers.js';
 export * from './modules/text.js';
 export * from './modules/styles.js';
-export * from './modules/props.js';
 export * from './modules/position.js';
 export * from './modules/events.js';
 export * from './modules/dom.js';

package/dist/index.js

@@ -6,7 +6,6 @@ export * from './modules/walk.js';
 export * from './modules/timers.js';
 export * from './modules/text.js';
 export * from './modules/styles.js';
-export * from './modules/props.js';
 export * from './modules/position.js';
 export * from './modules/events.js';
 export * from './modules/dom.js';

package/dist/modules/attrs.js

@@ -47,7 +47,7 @@ export class AttrHandler {
                 el.removeAttribute(nameOrObject);
             }
             else if (typeof nameOrObject === 'object') {
-                Object.entries(nameOrObject).forEach(([name, val]) => {
+                Object.entries(nameOrObject).forEach(([name]) => {
                     el.removeAttribute(name);
                 });
             }

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/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.insertAdjacentText('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.insertAdjacentText('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.textContent = 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

@@ -10,15 +10,16 @@ type cd = Record<'timeout' | 'interval', number> & HandlerCallBack;
 type cds = Record<'clearTimeout' | 'clearInterval', HandlerCallBackFn>;
 type TimerHandlerHandle = cd & cds;
 export declare class TimersHandler implements CommonHandler<TimersHandler> {
+    #private;
     private beElement;
     static methods: timersMethods[];
-    _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

@@ -9,11 +9,19 @@ var timersMethods;
 export class TimersHandler {
     beElement;
     static methods = Object.values(timersMethods);
-    _timer = null;
-    _interval = null;
+    #timer = null;
+    #interval = null;
     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.timerOut = setTimeout(() => {
+            callback?.({
+                method: 'timeout',
+                fragment: this.beElement.timerOut,
+                be: this.beElement,
+                root: this.beElement
+            });
+        }, value);
+        /* this.beElement.eachNode((el: HTMLElement) => {
             const aug = be(el);
             aug.BeTimer = setTimeout(() => {
                 callback?.({
@@ -42,43 +58,67 @@ export class TimersHandler {
                     root: this.beElement
                 });
             }, value);
-        });
+        }); */
         return this.beElement;
     }
     interval(value, callback) {
-        this.beElement.eachNode((el) => {
+        this.beElement.timerInterval = setInterval(() => {
+            callback?.({
+                method: 'interval',
+                fragment: this.beElement.timerInterval,
+                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
-            });
+        if (this.beElement.timerOut)
+            clearTimeout(this.beElement.timerOut);
+        this.beElement.timerOut = 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
-            });
+        if (this.beElement.timerInterval)
+            clearInterval(this.beElement.timerInterval);
+        this.beElement.timerInterval = 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.83.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",

package/dist/modules/props.d.ts

@@ -1,28 +0,0 @@
-import { Be } from '../be.js';
-import type { CommonHandler, HandlerCallBack, HandlerCallBackFn } from '../types.js';
-declare enum PropsMethods {
-    set = "set",
-    get = "get",
-    delete = "delete",
-    getKey = "getKey"
-}
-export interface PropsHandlerHandle {
-    set?: {
-        [key: string]: unknown;
-    } & HandlerCallBack;
-    delete?: {
-        keys: string[];
-    } & HandlerCallBack;
-}
-export declare class PropsHandler implements CommonHandler<PropsHandler, PropsHandlerHandle> {
-    private beElement;
-    static methods: PropsMethods[];
-    constructor(element: Be);
-    handle(actions: PropsHandlerHandle): Be;
-    get(name: string, callback?: HandlerCallBackFn): any;
-    set(nameOrObject: string | Record<string, any>, value?: any, callback?: HandlerCallBackFn): Be;
-    delete(name: string, callback?: HandlerCallBackFn): Be;
-    getKey(key: string, callback?: HandlerCallBackFn): string | null;
-    valueOf(): Record<string, any> | null;
-}
-export {};

package/dist/modules/props.js

@@ -1,67 +0,0 @@
-import { Be } from '../be.js';
-var PropsMethods;
-(function (PropsMethods) {
-    PropsMethods["set"] = "set";
-    PropsMethods["get"] = "get";
-    PropsMethods["delete"] = "delete";
-    PropsMethods["getKey"] = "getKey";
-})(PropsMethods || (PropsMethods = {}));
-export class PropsHandler {
-    beElement;
-    static methods = Object.values(PropsMethods);
-    constructor(element) {
-        this.beElement = element;
-    }
-    handle(actions) {
-        if (!actions)
-            return this.beElement;
-        Object.entries(actions).forEach(([method, props]) => {
-            switch (method) {
-                case 'set':
-                    {
-                        const [key, val] = Object.entries(props)[0];
-                        this.set(key, val, props.callback);
-                    }
-                    break;
-                case 'delete':
-                    this.delete(props.delete);
-                    break;
-            }
-        });
-        return this.beElement;
-    }
-    get(name, callback) {
-        if (this.beElement.isWhat !== 'element')
-            return null;
-        return this.beElement.inputNode[name];
-    }
-    set(nameOrObject, value, callback) {
-        this.beElement.eachNode((el) => {
-            if (typeof nameOrObject === 'string' && value !== undefined) {
-                el[nameOrObject] = value;
-            }
-            else if (typeof nameOrObject === 'object') {
-                Object.entries(nameOrObject).forEach(([name, val]) => {
-                    el[name] = val;
-                });
-            }
-        });
-        return this.beElement;
-    }
-    delete(name, callback) { }
-    getKey(key, callback) {
-        return null;
-    }
-    valueOf() {
-        if (this.beElement.isWhat !== 'element')
-            return null;
-        const el = this.beElement.inputNode;
-        const props = {};
-        for (let prop in el) {
-            if (el.hasOwnProperty(prop)) {
-                props[prop] = el[prop];
-            }
-        }
-        return props;
-    }
-}