ziko 0.33.0 → 0.34.1

package/src/reactivity/events/Pointer.js

@@ -1,232 +0,0 @@
-import {ZikoEvent,EVENT_CONTROLLER} from "./ZikoEvent.js";
-function pointerdown_controller(e){
-    EVENT_CONTROLLER.call(
-        this,
-        e,
-        "down",
-        ()=>{
-            this.dx=parseInt(e.offsetX);
-            this.dy=parseInt(e.offsetY);
-            this.isDown=true;
-        },
-        {
-            x:this.dx,
-            y:this.dy,
-            t:Date.now()-this.cache.stream.t0
-        }  
-    )
-}
-function pointermove_controller(e){
-    EVENT_CONTROLLER.call(
-        this,
-        e,
-        "move",
-        ()=>{
-            this.mx=parseInt(e.offsetX);
-            this.my=parseInt(e.offsetY);
-            this.isMoving=true;
-        },
-        {
-            x:this.mx,
-            y:this.my,
-            t:Date.now()-this.cache.stream.t0
-        }    
-    )
-}
-function pointerup_controller(e){
-    EVENT_CONTROLLER.call(
-        this,
-        e,
-        "up",
-        ()=>{
-            this.ux=parseInt(e.offsetX);
-            this.uy=parseInt(e.offsetY);
-            this.isDown=false;
-            const dx=this.dx;
-            const dy=this.dy;
-            const ux=this.ux;
-            const uy=this.uy;
-            const delta_x=(ux-dx)/this.target.Width;
-            const delta_y=(dy-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
-            }
-        },
-        {
-            x:this.ux,
-            y:this.uy,
-            t:Date.now()-this.cache.stream.t0
-        }    
-    )
-}
-function pointerenter_controller(e){
-    EVENT_CONTROLLER.call(
-        this,
-        e,
-        "enter",
-        null,
-        null    
-    )
-}
-function pointerleave_controller(e){
-    EVENT_CONTROLLER.call(
-        this,
-        e,
-        "leave",
-        null,
-        null    
-    )
-}
-function pointerout_controller(e){
-    EVENT_CONTROLLER.call(
-        this,
-        e,
-        "out",
-        null,
-        null    
-    )
-}
-function pointercancel_controller(e){
-    EVENT_CONTROLLER.call(
-        this,
-        e,
-        "cancel",
-        null,
-        null    
-    )
-}
-class ZikoEventPointer extends ZikoEvent{
-    constructor(target){
-        super(target);
-        this.event=null;
-        this.dx=0;
-        this.dy=0;
-        this.dt=0;
-        this.mx=0;
-        this.my=0;
-        this.mt=0;
-        this.ux=0;
-        this.uy=0;      
-        this.ut=0;
-        this.swippe={
-            h:null,
-            v:null,
-            delta_x:0,
-            delta_y:0
-        }
-        this.isMoving=false;
-        this.isDown=false;
-        this.cache={
-            prefixe:"pointer",
-            preventDefault:{
-                down:false,
-                move:false,
-                up:false,
-                enter:false,
-                out:false,
-                leave:false,
-                cancel:false
-            },
-            paused:{
-                down:false,
-                move:false,
-                up:false,
-                enter:false,
-                out:false,
-                leave:false,
-                cancel:false          
-            },
-            stream:{
-                enabled:{
-                    down:false,
-                    move:false,
-                    up:false,
-                    enter:false,
-                    out:false,
-                    leave:false,
-                    cancel:false
-                },
-                clear:{
-                    down:false,
-                    move:false,
-                    up:false,
-                    enter:false,
-                    out:false,
-                    leave:false,
-                    cancel:false            
-                },
-                history:{
-                    down:[],
-                    move:[],
-                    up:[],
-                    enter:[],
-                    out:[],
-                    leave:[]
-                }
-            },
-            callbacks:{
-                down:[(self)=>console.log({dx:self.dx,dy:self.dy,down:self.down,move:self.move,t:self.dt})],
-                move:[(self)=>console.log({mx:self.mx,my:self.my,down:self.down,move:self.move,t:self.dt})],
-                up:[(self)=>console.log({ux:self.ux,uy:self.uy,down:self.down,move:self.move,t:self.dt})],
-                enter:[(self)=>console.log({dx:self.dx,dy:self.dy,down:self.down,move:self.move,t:self.dt})],
-                out:[(self)=>console.log({mx:self.mx,my:self.my,down:self.down,move:self.move,t:self.dt})],
-                leave:[(self)=>console.log({ux:self.ux,uy:self.uy,down:self.down,move:self.move,t:self.dt})],
-                cancel:[(self)=>console.log({ux:self.ux,uy:self.uy,down:self.down,move:self.move,t:self.dt})]
-            }
-        }
-        this.__controller={
-            down:pointerdown_controller.bind(this),
-            move:pointermove_controller.bind(this),
-            up:pointerup_controller.bind(this),
-            enter:pointerenter_controller.bind(this),
-            out:pointerout_controller.bind(this),
-            leave:pointerleave_controller.bind(this),
-            cancel:pointercancel_controller.bind(this),
-        }
-    }
-    onDown(...callbacks){
-        if(callbacks.length===0)callbacks=[()=>{}];
-        this.__onEvent("down",{down:true,move:false,up:false,enter:false,out:false,leave:false,cancel:false},...callbacks)
-        return this;
-    }
-    onMove(...callbacks){
-        if(callbacks.length===0)callbacks=[()=>{}];
-        this.__onEvent("move",{down:false,move:true,up:false,enter:false,out:false,leave:false,cancel:false},...callbacks)
-        return this;
-    }
-    onUp(...callbacks){
-        if(callbacks.length===0)callbacks=[()=>{}];
-        this.__onEvent("up",{down:false,move:false,up:true,enter:false,out:false,leave:false,cancel:false},...callbacks)
-        return this;
-    }
-    onEnter(...callbacks){
-        if(callbacks.length===0)callbacks=[()=>{}];
-        this.__onEvent("enter",{down:false,move:false,up:false,enter:true,out:false,leave:false,cancel:false},...callbacks)
-        return this;
-    }
-    onOut(...callbacks){
-        if(callbacks.length===0)callbacks=[()=>{}];
-        this.__onEvent("out",{down:false,move:false,up:false,enter:false,out:true,leave:false,cancel:false},...callbacks)
-        return this;
-    }
-    onLeave(...callbacks){
-        if(callbacks.length===0)callbacks=[()=>{}];
-        this.__onEvent("leave",{down:false,move:false,up:false,enter:false,out:false,leave:true,cancel:false},...callbacks)
-        return this;
-    }
-    onCancel(...callbacks){
-        if(callbacks.length===0)callbacks=[()=>{}];
-        this.__onEvent("cancel",{down:false,move:false,up:false,enter:false,out:false,leave:false,cancel:true},...callbacks)
-        return this;
-    }
-}
-var usePointerEvent=target=>new ZikoEventPointer(target)
-export{
-    usePointerEvent,
-    ZikoEventPointer
-}

package/src/reactivity/events/click.js

@@ -1,102 +0,0 @@
-import { ZikoEvent , EVENT_CONTROLLER } from "./ZikoEvent.js";
-function click_controller(e){
-    EVENT_CONTROLLER.call(this,e,"click",null,null)
-}
-function dbclick_controller(e){
-    EVENT_CONTROLLER.call(this,e,"dbclick",null,null)
-}
-class ZikoEventClick extends ZikoEvent{
-    constructor(target){
-        super(target);
-        this.event=null;
-        this.cache={
-            prefixe:"",
-            preventDefault:{
-                click:false,
-                dbclick:false,
-            },
-            paused:{
-                click:false,
-                dbclick:false,      
-            },
-            stream:{
-                enabled:{
-                    click:false,
-                    dbclick:false,
-                },
-                clear:{
-                    click:false, 
-                    dbclick:false,         
-                },
-                history:{
-                    click:[],
-                    dbclick:[],
-                }
-            },
-            callbacks:{
-                click:[],
-                dbclick:[],
-            }
-        }
-        this.__controller={
-            click:click_controller.bind(this),
-            dbclick:dbclick_controller.bind(this),
-        }
-    }
-    onClick(...callbacks){
-        this.__onEvent("click",{},...callbacks)
-        return this;
-     }
-    onDbClick(...callbacks){
-        this.__onEvent("dbclick",{},...callbacks)
-        return this;
-     }     
-}
-const useClickEvent=target=>new ZikoEventClick(target);
-export default useClickEvent;
-export {
-    useClickEvent,
-    ZikoEventClick
-}
-
-
-// 
-
-
-// import { ZikoEvent, EVENT_CONTROLLER } from "./ZikoEvent.js";
-
-// class ZikoEventClick extends ZikoEvent {
-//     constructor(target) {
-//         super(target);
-//         this.event = null;
-//         this.cache = {
-//             prefixe: "",
-//             preventDefault: { click: false, dbclick: false },
-//             paused: { click: false, dbclick: false },
-//             stream: {
-//                 enabled: { click: false, dbclick: false },
-//                 clear: { click: false, dbclick: false },
-//                 history: { click: [], dbclick: [] }
-//             },
-//             callbacks: { click: [], dbclick: [] }
-//         };
-        
-//         this.__controller = {};
-//         ["click", "dbclick"].forEach(evt => {
-//             this.__controller[evt] = (e) => EVENT_CONTROLLER.call(this, e, evt, null, null);
-//         });
-//     }
-
-//     onClick(...callbacks) {
-//         return this.__onEvent("click", {}, ...callbacks);
-//     }
-
-//     onDbClick(...callbacks) {
-//         return this.__onEvent("dbclick", {}, ...callbacks);
-//     }
-// }
-
-// const useClickEvent = (target) => new ZikoEventClick(target);
-
-// export default useClickEvent;
-// export { useClickEvent, ZikoEventClick };

package/src/reactivity/events/clipboard.js

@@ -1,88 +0,0 @@
-import { ZikoEvent , EVENT_CONTROLLER } from "./ZikoEvent.js";
-function copy_controller(e){
-    EVENT_CONTROLLER.call(this,e,"copy",null,null)
-}
-function cut_controller(e){
-    EVENT_CONTROLLER.call(this,e,"cut",null,null)
-}
-function paste_controller(e){
-    EVENT_CONTROLLER.call(this,e,"paste",null,null)
-}
-function select_controller(e){
-    EVENT_CONTROLLER.call(this,e,"select",null,null)
-}
-class ZikoEventClipboard extends ZikoEvent{
-    constructor(target){
-        super(target);
-        this.event=null;
-        this.cache={
-            prefixe:"",
-            preventDefault:{
-                copy:false,
-                cut:false,
-                paste:false,
-                select:false
-            },
-            paused:{
-                copy:false,
-                cut:false,
-                paste:false,  
-                select:false  
-            },
-            stream:{
-                enabled:{
-                    copy:false,
-                    cut:false,
-                    paste:false,
-                    select:false,
-                },
-                clear:{
-                    copy:false,
-                    cut:false,
-                    paste:false, 
-                    select:false,      
-                },
-                history:{
-                    copy:[],
-                    cut:[],
-                    paste:[],
-                    select:[]
-                }
-            },
-            callbacks:{
-                copy:[],
-                cut:[],
-                paste:[],
-                select:[]
-            }
-        }
-        this.__controller={
-            copy:copy_controller.bind(this),
-            cut:cut_controller.bind(this),
-            paste:paste_controller.bind(this),
-            select:select_controller.bind(this)
-        }
-    }
-    onCopy(...callbacks){
-        this.__onEvent("copy",{},...callbacks)
-        return this;
-     } 
-    onCut(...callbacks){
-        this.__onEvent("cut",{},...callbacks)
-        return this;
-     } 
-    onPaste(...callbacks){
-        this.__onEvent("paste",{},...callbacks)
-        return this;
-     }   
-    onSelect(...callbacks){
-        this.__onEvent("select",{},...callbacks)
-        return this;
-     }   
-}
-const useClipboardEvent=target=>new ZikoEventClipboard(target);
-// export default useClipboardEvent
-export{
-    useClipboardEvent,
-    ZikoEventClipboard
-}

package/src/reactivity/events/drag.js

@@ -1,137 +0,0 @@
-import { ZikoEvent , EVENT_CONTROLLER } from "./ZikoEvent.js";
-function dragstart_controller(e){
-    EVENT_CONTROLLER(this,e,"start",null,null)
-}
-function drag_controller(e){
-    EVENT_CONTROLLER.call(this,e,"drag",null,null)
-}
-function dragend_controller(e){
-    EVENT_CONTROLLER.call(this,e,"end",null,null)
-}
-function drop_controller(e){
-    EVENT_CONTROLLER.call(this,e,"drop",null,null)
-}
-
-class ZikoEventDrag extends ZikoEvent{
-    constructor(target){
-        super(target)
-        this.target.setAttribute("draggable",true);
-        this.cache={
-            prefixe:"drag",
-            preventDefault:{
-                drag:false,
-                start:false,
-                end:false,
-                enter:false,
-                leave:false,
-                over:false,
-            },
-            paused:{
-                drag:false,
-                start:false,
-                end:false,
-                enter:false,
-                leave:false,
-                over:false,
-            },
-            enabled:{
-                drag:false,
-                start:false,
-                end:false,
-                enter:false,
-                leave:false,
-                over:false,
-            },
-            callbacks:{
-                drag:[],
-                start:[],
-                end:[],
-                enter:[],
-                leave:[],
-                over:[]
-            },
-            stream:{
-                enabled:{
-                    drag:false,
-                    start:false,
-                    end:false,
-                    enter:false,
-                    leave:false,
-                    over:false,
-                },
-                clear:{
-                    drag:false,
-                    start:false,
-                    end:false,
-                    enter:false,
-                    leave:false,
-                    over:false,
-                },
-                history:{
-                    drag:[],
-                    start:[],
-                    end:[],
-                    enter:[],
-                    leave:[],
-                    over:[],
-                }
-            }
-        }
-        this.__controller={
-            start:dragstart_controller.bind(this),
-            drag:drag_controller.bind(this),
-            end:dragend_controller.bind(this)
-        }
-    }
-    onStart(...callbacks){
-        this.__onEvent("start",{},...callbacks);
-        return this;
-    }
-    onDrag(...callbacks){
-        this.__onEvent("drag",{},...callbacks);
-        return this;
-    }
-    onEnd(...callbacks){
-        this.__onEvent("end",{},...callbacks);
-        return this;
-    }
-}
-class ZikoEventDrop extends ZikoEvent{
-    constructor(target){
-        super(target);
-        this.event=null;
-        this.cache={
-            prefixe:"",
-            preventDefault:{
-                drop:false,
-            },
-            paused:{
-                drop:false,      
-            },
-            stream:{
-                enabled:{
-                    drop:false,
-                },
-                clear:{
-                    drop:false,          
-                },
-                history:{
-                    drop:[],
-                }
-            },
-            callbacks:{
-                drop:[(self)=>console.log({dx:self.dx,dy:self.dy,drop:self.drop,move:self.move,t:self.dt})],
-            }
-        }
-        this.__controller={
-            drop:drop_controller.bind(this),
-        }
-    }
-    onDrop(...callbacks){
-        this.__onEvent("drop",{},...callbacks);
-        return this;
-    } 
-}
-const useDragEvent=target=>new ZikoEventDrag(target);
-const useDropEvent=target=>new ZikoEventDrop(target);
-export {useDragEvent,useDropEvent}

package/src/reactivity/events/focus.js

@@ -1,59 +0,0 @@
-import { ZikoEvent , EVENT_CONTROLLER } from "./ZikoEvent.js";
-function focus_controller(e){
-    EVENT_CONTROLLER.call(this,e,"focus",null,null)
-}
-function blur_controller(e){
-    EVENT_CONTROLLER.call(this,e,"blur",null,null)
-}
-class ZikoEventFocus extends ZikoEvent{
-    constructor(target){
-        super(target);
-        this.event=null;
-        this.cache={
-            prefixe:"",
-            preventDefault:{
-                focus:false,
-                blur:false,
-            },
-            paused:{
-                focus:false,
-                blur:false,      
-            },
-            stream:{
-                enabled:{
-                    focus:false,
-                    blur:false,
-                },
-                clear:{
-                    focus:false, 
-                    blur:false,         
-                },
-                history:{
-                    focus:[],
-                    blur:[],
-                }
-            },
-            callbacks:{
-                focus:[],
-                blur:[],
-            }
-        }
-        this.__controller={
-            focus:focus_controller.bind(this),
-            blur:blur_controller.bind(this),
-        }
-    }
-    onFocus(...callbacks){
-        this.__onEvent("focus",{},...callbacks)
-        return this;
-     }
-    onBlur(...callbacks){
-        this.__onEvent("blur",{},...callbacks)
-        return this;
-     }     
-}
-const useFocusEvent=target=>new ZikoEventFocus(target);
-export{
-    useFocusEvent,
-    ZikoEvent
-}