ziko 0.50.1 → 0.51.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.50.1",
+  "version": "0.51.0",
   "description": "A versatile JavaScript library offering a rich set of Hyperscript Based UI components, advanced mathematical utilities, interactivity ,animations, client side routing and more ...",
   "keywords": [
     "front-end",

package/src/__helpers__/checkers/index.js

@@ -1 +1,2 @@
 export const is_primitive = value => typeof value !== 'object' && typeof value !== 'function' || value === null;
+export const is_async = fn => fn && fn.constructor && fn.constructor.name === "AsyncFunction";

package/src/data/api/fetchdom.js

@@ -1,14 +1,30 @@
-import { preload } from "./preload"
+import { preload } from "./preload";
 
-async function fetchdom(url='https://github.com/zakarialaoui10'){
-  const data=await fetch(url)
-  const html=await data.text()
-  const dom= new DOMParser().parseFromString(html,'text/xml')
-  return dom.documentElement
+async function fetchdom(url='https://github.com/zakarialaoui10') {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+    const html = await response.text();
+    const dom = new DOMParser().parseFromString(html, 'text/html');
+    return dom.documentElement;
+  } catch (err) {
+    console.error('Failed to fetch DOM:', err);
+    throw err;
+  }
 }
-function fetchdomSync(url='https://github.com/zakarialaoui10'){
-  const data=preload(url);
-  const dom= new DOMParser().parseFromString(data,'text/xml')
-  return dom.documentElement;
+
+function fetchdomSync(url='https://github.com/zakarialaoui10') {
+  try {
+    const data = preload(url);
+    const dom = new DOMParser().parseFromString(data, 'text/html');
+    return dom.documentElement;
+  } catch (err) {
+    console.error('Failed to fetch DOM synchronously:', err);
+    throw err;
+  }
 }
-export {fetchdom,fetchdomSync}
+
+export { 
+  fetchdom, 
+  fetchdomSync 
+};

package/src/events/binders/coordinates-based-event.js

@@ -0,0 +1,25 @@
+import { ZikoEvent } from "../ziko-event.js";
+
+export class CoordinatesBasedEvent extends ZikoEvent{
+    constructor(signature, target = null, Events = [], details_setter, customizer){
+        super(signature, target, Events, details_setter, customizer)
+        Object.assign(this.cache,{
+            useNormalisedCoordinates : false
+        })
+        this.isDown = false;
+        this.isMoving = false;
+        this.dx = 0;
+        this.dy = 0;
+        this.mx = 0;
+        this.my = 0;
+        this.ux = 0;
+        this.uy = 0;
+    }
+    get isDragging(){
+        return this.isDown && this.isMoving
+    }
+    useNormalisedCoordinates(enable = true){
+        this.cache.useNormalisedCoordinates = enable;
+        return this;
+    }
+}

package/src/events/binders/custom-event.js

@@ -1,7 +1,7 @@
 import { ZikoEvent } from "../ziko-event.js";
 class ZikoCustomEvent extends ZikoEvent{
     constructor(target, events, customizer){
-        super(target, events, details_setter, customizer)
+        super('custom', target, events, details_setter, customizer)
     }
     _register_events(events){
         super._register_events(events, null, null, false);

package/src/events/binders/index.js

@@ -2,13 +2,23 @@ import { ZikoEvent } from "../ziko-event.js";
 import { EventsMap } from "../events-map/index.js";
 import {
     ptr_details_setter,
-    key_details_setter
+    key_details_setter,
+    mouse_details_setter,
+    touch_details_setter
 } from '../details-setter/index.js'
-import { register_click_away_event } from "../custom-events-registry/click-away.js";
+import {
+    CoordinatesBasedEvent
+} from './coordinates-based-event.js'
+import { 
+    register_click_away_event,
+    register_view_event,
+    register_swipe_event
+} from "../custom-events-registry/index.js";
 
 export const bind_click_event = (target, customizer) => {
     register_click_away_event(target.element)
     return new ZikoEvent(
+        'click',
         target,
         EventsMap.Click,
         null,
@@ -16,57 +26,80 @@ export const bind_click_event = (target, customizer) => {
     );
 }
 export const bind_clipboard_event = (target, customizer) => new ZikoEvent(
+    'clipboard',
     target,
     EventsMap.Clipboard,
     null,
     customizer
 );
 export const bind_drag_event = (target, customizer) => new ZikoEvent(
+    'drag',
     target,
     EventsMap.Drag,
     null,
     customizer
 );
 export const bind_focus_event = (target, customizer) => new ZikoEvent(
+    'focus',
     target,
     EventsMap.Focus,
     null,
     customizer
 );
 export const bind_key_event = (target, customizer) => new ZikoEvent(
+    'key',
     target,
     EventsMap.Key, 
     key_details_setter, 
     customizer
 );
-export const bind_mouse_event = (target, customizer) => new ZikoEvent(
+export const bind_mouse_event = (target, customizer) => new CoordinatesBasedEvent(
+    'mouse',
     target,
     EventsMap.Mouse,
-    null,
+    mouse_details_setter,
     customizer
 );
-export const bind_pointer_event = (target, customizer) => new ZikoEvent(
+export const bind_pointer_event = (target, customizer) => new CoordinatesBasedEvent(
+    'ptr',
     target,
     EventsMap.Ptr, 
     ptr_details_setter, 
     customizer
 );
-export const bind_touch_event = (target, customizer) => new ZikoEvent(
+export const bind_touch_event = (target, customizer) => new CoordinatesBasedEvent(
+    'touch',
     target,
     EventsMap.Touch,
-    null,
+    touch_details_setter,
     customizer
 );
 export const bind_wheel_event = (target, customizer) => new ZikoEvent(
+    'wheel',
     target,
     EventsMap.Wheel,
     null,
     customizer
 );
 
+export const bind_view_event = (target, customizer) => {
+    register_view_event(target.element)
+    return new ZikoEvent(
+        'view',
+        target, 
+        EventsMap.View,
+        null, 
+        customizer
+    )
+}
 
-// function details_setter(){
-//     if(this.currentEvent==="click") this.dx = 0
-//     else this.dx = 1
-//     // console.log(this.currentEvent)
-// }
+export const bind_swipe_event = (target, customizer) => {
+    register_swipe_event(target.element)
+    return new ZikoEvent(
+        'swipe',
+        target, 
+        EventsMap.Swipe,
+        null, 
+        customizer
+    )
+}

package/src/events/custom-events-registry/index.js

@@ -1 +1,3 @@
-export * from './click-away.js'
+export * from './click-away.js'
+export * from './view.js'
+export * from './swipe.js'

package/src/events/custom-events-registry/swipe.js

@@ -1,58 +1,76 @@
-class SwipeEvent extends Event {
-  constructor(type, direction, distX, distY, originalEvent) {
-    super(type, { bubbles: true, cancelable: true });
-    this.direction = direction; // "left" | "right" | "up" | "down"
-    this.distX = distX;
-    this.distY = distY;
-    this.originalEvent = originalEvent;
+class SwipeEvent extends CustomEvent {
+  constructor(type, detail) {
+    super(type, {
+      detail,
+      bubbles: true,
+      cancelable: true
+    });
   }
 }
 
-function register_swipe_event(element, threshold = 50, restraint = 100, allowedTime = 500) {
-  let startX, startY, startTime, isPointerDown = false;
+function register_swipe_event(
+  element,
+  threshold = 50,
+  restraint = 100,
+  allowedTime = 500
+) {
+  let startX = 0,
+      startY = 0,
+      startTime = 0,
+      isPointerDown = false;
+
   function onPointerDown(e) {
     startX = e.clientX;
     startY = e.clientY;
-    startTime = Date.now();
+    startTime = performance.now();
     isPointerDown = true;
   }
+
   function onPointerUp(e) {
     if (!isPointerDown) return;
     isPointerDown = false;
 
     const distX = e.clientX - startX;
     const distY = e.clientY - startY;
-    const elapsedTime = Date.now() - startTime;
+    const elapsed = performance.now() - startTime;
+
     let direction = null;
     let eventName = null;
 
-    if (elapsedTime <= allowedTime) {
+    if (elapsed <= allowedTime) {
       if (Math.abs(distX) >= threshold && Math.abs(distY) <= restraint) {
         direction = distX < 0 ? "left" : "right";
         eventName = "swipe" + direction;
-      } else if (Math.abs(distY) >= threshold && Math.abs(distX) <= restraint) {
+      } 
+      else if (Math.abs(distY) >= threshold && Math.abs(distX) <= restraint) {
         direction = distY < 0 ? "up" : "down";
         eventName = "swipe" + direction;
       }
     }
 
-    if (eventName && direction) {
+    // Emit event
+    if (eventName) {
       element.dispatchEvent(
-        new SwipeEvent(eventName, direction, distX, distY, e),
+        new SwipeEvent(eventName, {
+          direction,
+          distX,
+          distY,
+          originalEvent: e
+        })
       );
     }
   }
 
-  element.addEventListener("pointerdown", onPointerDown, false);
-  element.addEventListener("pointerup", onPointerUp, false);
+  element.addEventListener("pointerdown", onPointerDown, { passive: true });
+  element.addEventListener("pointerup", onPointerUp, { passive: true });
 
   return () => {
-    element.removeEventListener("pointerdown", onPointerDown, false);
-    element.removeEventListener("pointerup", onPointerUp, false);
+    element.removeEventListener("pointerdown", onPointerDown);
+    element.removeEventListener("pointerup", onPointerUp);
   };
 }
 
-export{
-    SwipeEvent,
-    register_swipe_event
-}
+export {
+  SwipeEvent,
+  register_swipe_event
+};

package/src/events/custom-events-registry/view.js

@@ -1,30 +1,61 @@
-class ViewEvent extends Event {
-    constructor(type, detail) {
-    super(type, { bubbles: true, cancelable: true });
-    this.detail = detail;
+import { throttle } from "../../time/decorators/index.js";
+class ViewEvent extends CustomEvent {
+    constructor(type, detail, { bubbles = true, cancelable = true } = {}) {
+        super(type, { detail, bubbles, cancelable });
     }
 }
 
-function register_view_event(element, { intersection = true, resize = true, threshold = 0 } = {}) {
+function register_view_event(
+    element,
+    {
+        intersection = true,
+        resize = true,
+        threshold = 0,
+        throttleResize = 100,
+        throttleEnterExit = 0
+    } = {}
+) {
     let intersectionObserver, resizeObserver;
-    if (intersection) {
-        intersectionObserver = new IntersectionObserver(entries => {
-            for (let entry of entries) {
-            const type = entry.isIntersecting ? "enterView" : "exitView";
+    const resizeCallback = entries => {
+        for (let entry of entries) {
+            const { width, height } = entry.contentRect;
+
+            element.dispatchEvent(
+                new ViewEvent("resizeview", {
+                    width,
+                    height,
+                    entry
+                })
+            );
+        }
+    };
+
+    const throttledResize = throttleResize > 0
+        ? throttle(resizeCallback, throttleResize)
+        : resizeCallback;
+
+    const intersectionCallback = entries => {
+        for (let entry of entries) {
+            const type = entry.isIntersecting ? "enterview" : "exitview";
             element.dispatchEvent(new ViewEvent(type, entry));
-            }
-        }, { threshold });
+        }
+    };
+
+    const throttledIntersections = throttleEnterExit > 0
+        ? throttle(intersectionCallback, throttleEnterExit)
+        : intersectionCallback;
+
+    if (intersection) {
+        intersectionObserver = new IntersectionObserver(throttledIntersections, { threshold });
         intersectionObserver.observe(element);
     }
+
     if (resize) {
-        resizeObserver = new ResizeObserver(entries => {
-            for (let entry of entries) {
-            const { width, height } = entry.contentRect;
-            element.dispatchEvent(new ViewEvent("resizeView", { width, height, entry }));
-            }
-        });
+        resizeObserver = new ResizeObserver(throttledResize);
         resizeObserver.observe(element);
     }
+
+    // ---- UNREGISTER ----
     return () => {
         if (intersectionObserver) {
             intersectionObserver.unobserve(element);
@@ -37,7 +68,7 @@ function register_view_event(element, { intersection = true, resize = true, thre
     };
 }
 
-export{
+export {
     ViewEvent,
     register_view_event
-}
+};

package/src/events/details-setter/index.js

@@ -1,2 +1,4 @@
 export * from './key.js'
-export * from './pointer.js'
+export * from './pointer.js'
+export * from './mouse.js'
+export * from './touch.js'

package/src/events/details-setter/mouse.js

@@ -0,0 +1,35 @@
+export function mouse_details_setter() {
+    const rect = this.targetElement.getBoundingClientRect();
+    const e = this.event;
+    let x = (e.clientX - rect.left) | 0;
+    let y = (e.clientY - rect.top) | 0;
+
+    if(this.cache.useNormalisedCoordinates){
+        const w = this.targetElement.clientWidth;
+        const h = this.targetElement.clientHeight;
+        x = +((x / w) * 2 - 1).toFixed(8);
+        y = +((y / h) * -2 + 1).toFixed(8);
+    }
+
+    switch (this.currentEvent) {
+
+        case "mousedown":
+            this.dx = x;
+            this.dy = y;
+            this.isDown = true;
+            break;
+
+        case "mousemove":
+            this.mx = x;
+            this.my = y;
+            this.isMoving = true;
+            break;
+
+        case "mouserup":
+            this.ux = x;
+            this.uy = y;
+            this.isDown = false;
+            this.isMoving = false;
+            break;
+    }
+}

package/src/events/details-setter/pointer.js

@@ -1,33 +1,35 @@
-export function ptr_details_setter(){
-    switch(this.currentEvent){
-        case "pointerdown" : {
-            this.dx = parseInt(this.event.offsetX);
-            this.dy = parseInt(this.event.offsetY);
-            this.isDown = true
-        }; break;
-        case "pointermove" : {
-            this.mx = parseInt(this.event.offsetX);
-            this.my = parseInt(this.event.offsetY);
-            this.isMoving = true
-        }; break;
-        case "pointerup" : {
-            this.ux = parseInt(this.event.offsetX);
-            this.uy = parseInt(this.event.offsetY);
+export function ptr_details_setter() {
+    const rect = this.targetElement.getBoundingClientRect();
+    const e = this.event;
+    let x = (e.clientX - rect.left) | 0;
+    let y = (e.clientY - rect.top) | 0;
+
+    if(this.cache.useNormalisedCoordinates){
+        const w = this.targetElement.clientWidth;
+        const h = this.targetElement.clientHeight;
+        x = +((x / w) * 2 - 1).toFixed(8);
+        y = +((y / h) * -2 + 1).toFixed(8);
+    }
+    switch (this.currentEvent) {
+
+        case "pointerdown":
+            this.dx = x;
+            this.dy = y;
+            this.isDown = true;
+            break;
+
+        case "pointermove":
+            this.mx = x;
+            this.my = y;
+            this.isMoving = true;
+            break;
+
+        case "pointerup":
+            this.ux = x;
+            this.uy = y;
             this.isDown = false;
-            console.log(this.target.width)
-            const delta_x=(this.ux-this.dx)/this.target.width;
-            const delta_y=(this.dy-this.uy)/this.target.height;
-            const HORIZONTAL_SWIPPE=(delta_x<0)?"left":(delta_x>0)?"right":"none";
-            const VERTICAL_SWIPPE=(delta_y<0)?"bottom":(delta_y>0)?"top":"none";
-            this.swippe={
-                h:HORIZONTAL_SWIPPE,
-                v:VERTICAL_SWIPPE,
-                delta_x,
-                delta_y
-            }
-        }; break;
+            this.isMoving = false;
+            break;
     }
-    // if(this.currentEvent==="click") this.dx = 0
-    // else this.dx = 1
-    // console.log(this.currentEvent)
-}
+}
+

package/src/events/details-setter/touch.js

@@ -0,0 +1,37 @@
+export function touch_details_setter() {
+    const e = this.event;
+    const touch = e.touches?.[0] || e.changedTouches?.[0];
+
+    if (!touch) return; // should never happen but safe
+
+    const rect = this.targetElement.getBoundingClientRect();
+    let x = touch.clientX - rect.left;
+    let y = touch.clientY - rect.top;
+
+    if(this.cache.useNormalisedCoordinates){
+        const w = this.targetElement.clientWidth;
+        const h = this.targetElement.clientHeight;
+        x = +((x / w) * 2 - 1).toFixed(8);
+        y = +((y / h) * -2 + 1).toFixed(8);
+    }
+
+    switch (this.currentEvent) {
+        case "touchstart":
+            this.dx = x;
+            this.dy = y;
+            this.isDown = true;
+            break;
+
+        case "touchmove":
+            this.mx = x;
+            this.my = y;
+            this.isMoving = true;
+            break;
+
+        case "touchend":
+            this.ux = x;
+            this.uy = y;
+            this.isDown = false;
+            break;
+    }
+}

package/src/events/events-map/index.js

@@ -1,8 +1,4 @@
 const EventsMap = {
-    'Custom' : [
-        'emit',
-        'on'
-    ],
     'Click' : [
         'Click',
         'DblClick',
@@ -48,13 +44,25 @@ const EventsMap = {
     ],
     'Wheel': [
         'Wheel'
-    ]
+    ],
     // 'Media':[
 
     // ],
     // 'Hash':[
     //     "HashChange"
     // ]
+
+    'View':[
+        'EnterView',
+        'ExitView',
+        'ResizeView'
+    ],
+    'Swipe':[
+        'SwipeLeft',
+        'SwipeUp',
+        'SwipeRight',
+        'SwipeDown'
+    ]
 }
 
 export {

package/src/events/utils.js

@@ -1,3 +1,34 @@
+export function event_controller(e, event_name, details_setter, customizer) {
+    this.cache.currentEvent = event_name;
+    this.cache.event = e;
+
+    details_setter?.call(this);
+    if (customizer?.hasOwnProperty('prototype')) customizer?.call(this);
+    else customizer?.call(null, this);
+
+    if (this.cache.preventDefault[event_name]) e.preventDefault();
+    if (this.cache.stopPropagation[event_name]) e.stopPropagation();
+    if (this.cache.stopImmediatePropagation[event_name]) e.stopImmediatePropagation();
+
+    // Call the single callback if it exists
+    this.cache.callbacks[event_name]?.(this);
+}
+
+export function toggle_event_listener(method, ...events) {
+    const keys = events.length === 0
+        ? Object.keys(this.cache.paused) 
+        : events;
+    keys.forEach(key => {
+        if (!this.cache.paused.hasOwnProperty(key)) return;
+        this.targetElement?.[method](
+            key,
+            this.cache.__controllers__[key],
+            this.cache.options[key]
+        );
+        this.cache.paused[key] = method === 'removeEventListener';
+    });
+    return this;
+}
 const getEvent=(event = "")=>{
     if(event.startsWith("Ptr"))return `pointer${event.split("Ptr")[1].toLowerCase()}`;
     return event.toLowerCase()