ziko 0.0.5 → 0.0.6

package/core/Math/index.js

@@ -1,193 +0,0 @@
-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/core/Reactivity/Events/Global/Click.js

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

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

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

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

@@ -1,53 +0,0 @@
-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 customEvent(Target);
-export default customEvent;

package/core/Reactivity/Events/Global/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 Drag=Target=>new ZikoEventDrag(Target);
-const Drop=Target=>new ZikoEventDrop(Target);
-export {Drag,Drop}

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

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

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

@@ -1,104 +0,0 @@
-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