@medyll/idae-be 0.80.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

@@ -17,6 +17,11 @@ declare enum domMethods {
 }
 type Content = string | HTMLElement | Be;
 export interface DomHandlerHandle {
+    insert?: {
+        content: string | HTMLElement | Be;
+        mode: 'afterbegin' | 'afterend' | 'beforebegin' | 'beforeend';
+        callback?: (element: HandlerCallbackProps) => void;
+    };
     update?: {
         content: Content;
         callback?: (element: HandlerCallbackProps) => void;
@@ -65,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.
@@ -80,8 +86,8 @@ export declare class DomHandler implements DomHandlerInterface, CommonHandler<Do
     update(content: string, callback?: HandlerCallBackFn): Be;
     append(content: Content, callback?: HandlerCallBackFn): Be;
     prepend(content: Content, callback?: HandlerCallBackFn): Be;
-    insert(mode: 'afterbegin' | 'afterend' | 'beforebegin' | 'beforeend', element: HTMLElement | Be, callback?: HandlerCallBackFn): Be;
-    afterBegin(content: HTMLElement, callback?: HandlerCallBackFn): Be;
+    insert(mode: 'afterbegin' | 'afterend' | 'beforebegin' | 'beforeend', element: HTMLElement | Be | string, callback?: HandlerCallBackFn): Be;
+    afterBegin(content: Content, callback?: HandlerCallBackFn): Be;
     afterEnd(content: Content, callback?: HandlerCallBackFn): Be;
     beforeBegin(content: Content, callback?: HandlerCallBackFn): Be;
     beforeEnd(content: Content, callback?: HandlerCallBackFn): Be;
@@ -91,6 +97,8 @@ export declare class DomHandler implements DomHandlerInterface, CommonHandler<Do
     normalize(callback?: HandlerCallBackFn): Be;
     wrap(tag?: string, callback?: HandlerCallBackFn): Be;
     private adjacentElement;
+    private normalizeContent;
+    private insertContent;
     valueOf(): string | null;
 }
 export {};

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.
@@ -79,15 +80,13 @@ export class DomHandler {
     append(content, callback) {
         const ret = [];
         this.beElement.eachNode((el) => {
-            if (content instanceof Be) {
-                content.eachNode((child) => {
-                    ret.push(child);
-                    el.appendChild(child);
-                });
+            const normalizedContent = this.normalizeContent(content);
+            if (normalizedContent instanceof DocumentFragment) {
+                el.appendChild(normalizedContent);
             }
             else {
-                ret.push(content);
-                el.appendChild(content);
+                ret.push(normalizedContent);
+                el.appendChild(normalizedContent);
             }
         });
         callback?.({
@@ -100,15 +99,13 @@ export class DomHandler {
     prepend(content, callback) {
         const ret = [];
         this.beElement.eachNode((el) => {
-            if (content instanceof Be) {
-                content.eachNode((child) => {
-                    ret.push(child);
-                    el.insertBefore(child, el.firstChild);
-                });
+            const normalizedContent = this.normalizeContent(content);
+            if (normalizedContent instanceof DocumentFragment) {
+                el.insertBefore(normalizedContent, el.firstChild);
             }
             else {
-                ret.push(content);
-                el.insertBefore(content, el.firstChild);
+                ret.push(normalizedContent);
+                el.insertBefore(normalizedContent, el.firstChild);
             }
         });
         callback?.({
@@ -128,6 +125,8 @@ export class DomHandler {
                 return this.beforeBegin(element, callback);
             case 'beforeend':
                 return this.beforeEnd(element, callback);
+            default:
+                throw new Error(`Invalid mode: ${mode}`);
         }
     }
     afterBegin(content, callback) {
@@ -142,29 +141,51 @@ export class DomHandler {
         return this.beElement;
     }
     afterEnd(content, callback) {
-        this.append(content, callback);
+        this.beElement.eachNode((el) => {
+            // Insérer après l'élément cible
+            el.parentNode?.insertBefore(this.normalizeContent(content), el.nextSibling);
+            callback?.({
+                fragment: content,
+                be: be(el),
+                root: this.beElement
+            });
+        });
         return this.beElement;
     }
     beforeBegin(content, callback) {
-        this.prepend(content, callback);
+        this.beElement.eachNode((el) => {
+            // Insérer avant l'élément cible
+            el.parentNode?.insertBefore(this.normalizeContent(content), el);
+            callback?.({
+                fragment: content,
+                be: be(el),
+                root: this.beElement
+            });
+        });
         return this.beElement;
     }
     beforeEnd(content, callback) {
-        this.append(content, callback);
+        this.beElement.eachNode((el) => {
+            // Insérer à la fin de l'élément cible
+            el.appendChild(this.normalizeContent(content));
+            callback?.({
+                fragment: content,
+                be: be(el),
+                root: this.beElement
+            });
+        });
         return this.beElement;
     }
     replace(content, callback) {
         const ret = [];
         this.beElement.eachNode((el) => {
-            if (content instanceof Be) {
-                content.eachNode((child) => {
-                    ret.push(child);
-                    el.replaceWith(child);
-                });
+            const normalizedContent = this.normalizeContent(content);
+            if (normalizedContent instanceof DocumentFragment) {
+                el.replaceWith(...normalizedContent.childNodes);
             }
             else {
-                ret.push(content);
-                el.replaceWith(content);
+                ret.push(normalizedContent);
+                el.replaceWith(normalizedContent);
             }
         });
         callback?.({
@@ -223,8 +244,74 @@ export class DomHandler {
         return this.beElement;
     }
     adjacentElement(element, content, mode) {
-        element.insertAdjacentElement(mode, content);
-        return this.beElement;
+        const normalizedContent = this.normalizeContent(content);
+        if (typeof content === 'string') {
+            // Si le contenu est une chaîne HTML, utilisez insertAdjacentHTML
+            element.insertAdjacentHTML(mode, content);
+        }
+        else if (normalizedContent instanceof HTMLElement) {
+            // Si le contenu est un élément DOM, utilisez insertAdjacentElement
+            if (mode === 'afterend') {
+                element.parentNode?.insertBefore(normalizedContent, element.nextSibling);
+            }
+            else if (mode === 'beforebegin') {
+                element.parentNode?.insertBefore(normalizedContent, element);
+            }
+            else {
+                element.insertAdjacentElement(mode, normalizedContent);
+            }
+        }
+        else if (normalizedContent instanceof DocumentFragment) {
+            // Si le contenu est un fragment, insérez chaque nœud
+            Array.from(normalizedContent.childNodes).forEach((node) => {
+                if (mode === 'afterbegin' || mode === 'beforeend') {
+                    element.appendChild(node);
+                }
+                else if (mode === 'afterend') {
+                    element.parentNode?.insertBefore(node, element.nextSibling);
+                }
+                else if (mode === 'beforebegin') {
+                    element.parentNode?.insertBefore(node, element);
+                }
+            });
+        }
+    }
+    normalizeContent(content) {
+        if (typeof content === 'string') {
+            // Si le contenu est une chaîne HTML, créez un fragment DOM
+            const template = document.createElement('template');
+            template.innerHTML = content.trim();
+            return template.content;
+        }
+        else if (content instanceof Be) {
+            // Si le contenu est une instance de Be, utilisez son premier nœud
+            if (Array.isArray(content.node)) {
+                const fragment = document.createDocumentFragment();
+                content.node.forEach((node) => {
+                    if (node instanceof HTMLElement) {
+                        fragment.appendChild(node);
+                    }
+                });
+                return fragment;
+            }
+            else if (content.node instanceof HTMLElement) {
+                return content.node;
+            }
+            throw new Error('Invalid Be instance: no valid node found.');
+        }
+        else {
+            // Sinon, le contenu est déjà un HTMLElement
+            return content;
+        }
+    }
+    insertContent(el, content, mode) {
+        const normalizedContent = this.normalizeContent(content);
+        if (mode === 'afterEnd') {
+            el.parentNode?.insertBefore(normalizedContent, el.nextSibling);
+        }
+        else if (mode === 'beforeEnd') {
+            el.appendChild(normalizedContent);
+        }
     }
     valueOf() {
         if (this.beElement.isWhat !== 'element')

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.80.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",