ziko 0.0.1

package/src/Math/index.js

@@ -0,0 +1,193 @@
+import { __NumberProto__ } from "../__proto__/Number.js";
+import { __ArrayProto__ } from "../__proto__/Array.js";
+import {PI,E,EPSILON} from "./const.js"
+import { Signal } from "./Signal";
+// __NumberProto__()
+// __ArrayProto__()
+import{
+    cos,
+    sin,
+    tan,
+    sinc,
+    cot,
+    sec,
+    csc,
+    abs,
+    sqrt,
+    pow,
+    sqrtn,
+    e,
+    ln,
+    acos,
+    asin,
+    atan,
+    acot,
+    cosh,
+    sinh,
+    tanh,
+    coth,
+    acosh,
+    asinh,
+    atanh,
+    min,
+    max,
+    sign,
+    floor,
+    ceil,
+    round,
+    fact,
+    hypot,
+    sig,
+    atan2,
+  } from "./Functions";
+import {Random} from "./Random";
+//import { Derivation } from "./Numeric";
+import {complex,Complex} from "./Complex";
+import{Matrix,LinearSystem,matrix,matrix2,matrix3,matrix4}from "./Matrix"
+import Discret from "./Discret";
+import {Logic,Base,Permutation,Combinaison,powerSet,subSet} from "./Discret";
+import {
+    Utils,
+    zeros,
+    ones,
+    nums,
+    sum,
+    prod,
+    add,
+    mul,
+    div,
+    sub,
+    modulo,
+    rad2deg,
+    deg2rad,
+    arange,
+    linspace,
+    logspace,
+    geomspace,
+    norm,
+    lerp,
+    map,
+    clamp,
+    pgcd,
+    ppcm,
+    isApproximatlyEqual,
+    inRange,
+    cartesianProduct,
+    mapfun
+  }from "./Utils"
+const Math={
+    PI,
+    E,
+    EPSILON,
+    Random,
+    complex,
+    Complex,
+    Matrix,
+    LinearSystem,
+    matrix,
+    matrix2,
+    matrix3,
+    matrix4,
+    cos,
+    sin,
+    tan,
+    sinc,
+    sec,
+    csc,
+    cot,
+    abs,
+    sqrt,
+    pow,
+    sqrtn,
+    e,
+    ln,
+    acos,
+    asin,
+    atan,
+    acot,
+    cosh,
+    sinh,
+    tanh,
+    coth,
+    acosh,
+    asinh,
+    atanh,
+    min,
+    max,
+    sign,
+    floor,
+    ceil,
+    round,
+    fact,
+    hypot,
+    sig,
+    atan2,
+   // Derivation,
+    Utils,
+    mapfun,
+    nums,
+    zeros,
+    ones,
+    sum,
+    prod,
+    add,
+    mul,
+    div,
+    sub,
+    modulo,
+    rad2deg,
+    deg2rad,
+    arange,
+    linspace,
+    logspace,
+    geomspace,
+    norm,
+    lerp,
+    map,
+    clamp,
+    pgcd,
+    ppcm,
+    isApproximatlyEqual,
+    inRange,
+    cartesianProduct,
+    Discret,
+    Logic,
+    Base,
+    Permutation,
+    Combinaison,
+    powerSet,
+    subSet,
+    Signal,
+    ExtractAll: function () {
+        const keys = Object.keys(this);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (key !== 'ExtractAll' && key !== 'RemoveAll') {
+                globalThis[key] = this[key];
+            }
+        }
+        return this;
+    },
+    RemoveAll: function () {
+        const keys = Object.keys(this);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (key !== 'RemoveAll') {
+                delete globalThis[key];
+            }
+        }
+        return this;
+    }
+}
+export * from "./const.js"
+export * from "./Functions"
+export * from "./Complex"
+export * from "./Matrix"
+export * from "./Discret"
+export * from "./Numeric"
+export * from "./Random"
+export * from "./Signal"
+export * from "./Utils"
+export * from "./Statistics"
+export default Math;
+

package/src/Reactivity/Events/Global/Click.js

@@ -0,0 +1,56 @@
+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 Click=Target=>new ZikoEventClick(Target);
+export default Click

package/src/Reactivity/Events/Global/Clipboard.js

@@ -0,0 +1,84 @@
+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 Clipboard=Target=>new ZikoEventClipboard(Target);
+export default Clipboard

package/src/Reactivity/Events/Global/CustomEvent.js

@@ -0,0 +1,53 @@
+import { ZikoEvent , EVENT_CONTROLLER } from "../ZikoEvent.js";
+const custom_event_controller=event_name=>function(e){
+    EVENT_CONTROLLER.call(this,e,event_name,null,null)
+}
+class ZikoCustomEvent extends ZikoEvent{
+    constructor(target){
+        super(target);
+        this.event=null;
+        this.cache={
+            prefixe:"",
+            preventDefault:{
+            },
+            paused:{
+            },
+            stream:{
+                enabled:{
+                },
+                clear:{
+                },
+                history:{
+                }
+            },
+            callbacks:{
+            }
+        }
+        this.__controller={
+        }
+    }
+    #init(event_name){
+        this.cache.preventDefault[event_name]=false;
+        this.cache.paused[event_name]=false;
+        this.cache.stream.enabled=false;
+        this.cache.stream.clear=false;
+        this.cache.stream.history=[];
+        this.cache.callbacks[event_name]=[]
+        this.__controller[event_name]=custom_event_controller(event_name).bind(this);
+        return this;
+    }
+    on(event_name,...callbacks){
+        if(!(this.__controller[event_name]))this.#init(event_name);
+        this.__onEvent(event_name,{},...callbacks)
+        return this;
+     }  
+    emit(event_name,detail={}){
+        if(!(this.__controller[event_name]))this.#init(event_name);
+        this.detail=detail;
+        const event=new Event(event_name);
+        this.targetElement.dispatchEvent(event);
+        return this;
+    }
+}
+const CustomEvent=Target=>new ZikoCustomEvent(Target);
+export default CustomEvent;

package/src/Reactivity/Events/Global/Drag.js

@@ -0,0 +1,137 @@
+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 Drag=Target=>new ZikoEventDrag(Target);
+const Drop=Target=>new ZikoEventDrop(Target);
+export {Drag,Drop}

package/src/Reactivity/Events/Global/Focus.js

@@ -0,0 +1,56 @@
+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 Focus=Target=>new ZikoEventFocus(Target);
+export default Focus

package/src/Reactivity/Events/Global/Key.js

@@ -0,0 +1,104 @@
+import {ZikoEvent,EVENT_CONTROLLER} from "../ZikoEvent.js";
+function keydown_controller(e){
+    EVENT_CONTROLLER.call(
+        this,
+        e,
+        "down",
+        ()=>this.kd=e.key,
+        {key:e.key,t:10}
+        )
+}
+function keypress_controller(e){
+    EVENT_CONTROLLER.call(
+        this,
+        e,
+        "press",
+        ()=>this.kp=e.key,
+        {key:e.key,t:10}
+        )
+}
+function keyup_controller(e){
+    EVENT_CONTROLLER.call(
+        this,
+        e,
+        "up",
+        ()=>this.ku=e.key,
+        {key:e.key,t:10}
+        )
+}
+class ZikoEventKey extends ZikoEvent{
+    constructor(target){ 
+        super(target)
+        this.kp=null;
+        this.kd=null;
+        this.ku=null;
+        this.t=0;
+        this.cache={
+            prefixe:"key",
+            preventDefault:{
+                down:false,
+                press:false,
+                up:false,
+            },
+            paused:{
+                down:false,
+                press:false,
+                up:false,
+            },
+            stream:{
+                enabled:{
+                    down:false,
+                    press:false,
+                    up:false,
+                },
+                clear:{
+                    down:true,
+                    press:false,
+                    up:false,
+                },
+                history:{
+                    down:[],
+                    press:[],
+                    up:[],
+                }
+            },
+            callbacks:{
+                down:[(self)=>console.log({kd:self.kd})],
+                press:[(self)=>console.log({kp:self.kp})],
+                up:[(self)=>console.log({ku:self.ku})]
+            },
+            successifKeysCallback:{
+                down:[(self)=>console.log(1111)],
+                press:[(self)=>console.log(1112)],
+                kyup:[(self)=>console.log(1113)]
+            }
+        }
+        this.__controller={
+            down:keydown_controller.bind(this),
+            press:keypress_controller.bind(this),
+            up:keyup_controller.bind(this)
+        }
+    }
+    onDown(...callbacks){
+        this.__onEvent("down",{down:true},...callbacks)
+        return this;
+     }
+    onPress(...callbacks){
+        this.__onEvent("press",{press:true},...callbacks)
+        return this;
+     }
+    onUp(...callbacks){
+        this.__onEvent("up",{up:true},...callbacks)
+        return this;
+     }
+
+}
+
+var Key=Target=>new ZikoEventKey(Target)
+
+// handleDown(){
+//     this.dispose({down:true,press:false,up:false})
+//     this.Target.addEventListener("keydown",this.#downController);
+//     return this;
+//  }
+export default Key