ziko 0.0.1

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

@@ -0,0 +1,214 @@
+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    
+    )
+}
+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,
+            },
+            paused:{
+                down:false,
+                move:false,
+                up:false,
+                enter:false,
+                out:false,
+                leave:false,          
+            },
+            stream:{
+                enabled:{
+                    down:false,
+                    move:false,
+                    up:false,
+                    enter:false,
+                    out:false,
+                    leave:false,
+                },
+                clear:{
+                    down:false,
+                    move:false,
+                    up:false,
+                    enter:false,
+                    out:false,
+                    leave: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})]
+            }
+        }
+        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),
+        }
+    }
+    onDown(...callbacks){
+        if(callbacks.length===0)callbacks=[()=>{}];
+        this.__onEvent("down",{down:true,move:false,up:false,enter:false,out:false,leave: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},...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},...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},...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},...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},...callbacks)
+        return this;
+    }
+    // handle({down=false,move=false,up=false}={}){
+    //     if(down)this.handleDown();
+    //     if(move)this.handleMove();
+    //     if(up)this.handleUp()
+    // }
+}
+var Pointer=target=>new ZikoEventPointer(target)
+export default Pointer;

package/src/Reactivity/Events/Partiel/Input.js

@@ -0,0 +1,59 @@
+import { ZikoEvent , EVENT_CONTROLLER } from "../ZikoEvent.js";
+function input_controller(e){
+    EVENT_CONTROLLER.call(this,e,"input",null,null)
+}
+function change_controller(e){
+    EVENT_CONTROLLER.call(this,e,"change",null,null)
+}
+class ZikoEventInput extends ZikoEvent{
+    constructor(target){
+        super(target);
+        this.event=null;
+        this.cache={
+            prefixe:"",
+            preventDefault:{
+                input:false,
+                change:false,
+            },
+            paused:{
+                input:false,
+                change:false,      
+            },
+            stream:{
+                enabled:{
+                    input:false,
+                    change:false,
+                },
+                clear:{
+                    input:false, 
+                    change:false,         
+                },
+                history:{
+                    input:[],
+                    change:[],
+                }
+            },
+            callbacks:{
+                input:[],
+                change:[],
+            }
+        }
+        this.__controller={
+            input:input_controller.bind(this),
+            change:change_controller.bind(this),
+        }
+    }
+    get value(){
+        return this.target.value;
+    }
+    onInput(...callbacks){
+        this.__onEvent("input",{},...callbacks)
+        return this;
+     }
+    onChange(...callbacks){
+        this.__onEvent("change",{},...callbacks)
+        return this;
+     }     
+}
+const Input=Target=>new ZikoEventInput(Target);
+export default Input

package/src/Reactivity/Events/ZikoEvent.js

@@ -0,0 +1,91 @@
+function EVENT_CONTROLLER(e,EVENT,setter,push_object){
+    this.event=e
+    if(this.cache.preventDefault[EVENT])e.preventDefault();
+    if(setter)setter();
+    if(this.cache.stream.enabled[EVENT]&&push_object)this.cache.stream.history[EVENT].push(push_object);
+    this.cache.callbacks[EVENT].map(n=>n(this));
+    return this;
+}
+class ZikoEvent{
+    constructor(Target){
+        this.target=null;
+        this.setTarget(Target);
+        this.__dispose=this.dispose.bind(this);
+        // this.EventIndex=Garbage.Pointer.data.length;
+        // Garbage.Pointer.data.push({event:this,index:this.EventIndex});
+    }
+    get targetElement(){
+        return this.target.element
+    }
+    setTarget(UI){
+        this.target=UI;
+        return this;
+    }
+    __handle(event,handler,dispose){
+        const EVENT=(event==="drag")?event:`${this.cache.prefixe}${event}`
+        this.dispose(dispose);
+        this.targetElement.addEventListener(EVENT,handler);
+        return this;   
+    }
+    __onEvent(event,dispose,...callbacks){
+        if(callbacks.length===0){
+            if(this.cache.callbacks.length>1){
+                this.cache.callbacks.map(n=>e=>n.call(this,e));
+            }   
+            else {
+                return this;
+            }
+        }
+        else this.cache.callbacks[event]=callbacks.map(n=>e=>n.call(this,e));
+        this.__handle(event,this.__controller[event],dispose)
+        return this;  
+    }
+    preventDefault(config={}){
+        Object.assign(this.cache.preventDefault,config);
+        return this;
+    }
+    pause(config={}){
+        const all=Object.fromEntries(Object.keys(this.cache.stream.enabled).map(n=>[n,true]))
+        config={...all,...config}
+        for(let key in config){
+            if(config[key]){
+                this.targetElement.removeEventListener(`${this.cache.prefixe}${key}`,this.__controller[`${this.cache.prefixe}${key}`]);
+                this.cache.paused[`${this.cache.prefixe}${key}`]=true;
+            }
+        }
+        return this;
+     }
+    resume(config={}){
+        const all=Object.fromEntries(Object.keys(this.cache.stream.enabled).map(n=>[n,true]))
+        config={...all,...config}
+        for(let key in config){
+            if(config[key]){
+                this.targetElement.addEventListener(`${this.cache.prefixe}${key}`,this.__controller[`${this.cache.prefixe}${key}`]);
+                this.cache.paused[`${this.cache.prefixe}${key}`]=false;
+            }
+        }
+        return this;
+     }
+    dispose(config={}){
+        this.pause(config);
+        return this;
+     }
+    stream(config={}){
+        this.cache.stream.t0=Date.now();
+        const all=Object.fromEntries(Object.keys(this.cache.stream.enabled).map(n=>[n,true]))
+        config={...all,...config}
+        Object.assign(this.cache.stream.enabled,config);
+        return this;
+     }
+    clear(config={}){
+        const all=Object.fromEntries(Object.keys(this.cache.stream.clear).map(n=>[n,true]))
+        config={...all,...config}
+        for(let key in config){
+            if(config[key]){
+                this.cache.stream.history[key]=[]
+            }
+        }
+        return this;
+    }
+}
+export {ZikoEvent,EVENT_CONTROLLER}

package/src/Reactivity/Events/index.js

@@ -0,0 +1,51 @@
+import Pointer from "./Global/Pointer.js";
+import Key from "./Global/Key.js";
+import {Drag,Drop} from "./Global/Drag.js";
+import Click from "./Global/Click.js";
+import Clipboard from "./Global/Clipboard.js";
+import Focus from "./Global/Focus.js";
+import Input from "./Partiel/Input.js";
+import CustomEvent from "./Global/CustomEvent.js";
+const Events={
+    Pointer,
+    Key,
+    Drag,
+    Drop,
+    Click,
+    Clipboard,
+    Focus,
+    Input,
+    CustomEvent,
+    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 {
+    Pointer,
+    Key,
+    Drag,
+    Drop,
+    Click,
+    Clipboard,
+    Focus,
+    Input,
+    CustomEvent
+}
+export default Events

package/src/Reactivity/Observer/index.js

@@ -0,0 +1,3 @@
+export * from "./intersection";
+export * from "./mutation";
+export * from "./resize";

package/src/Reactivity/Observer/intersection.js

@@ -0,0 +1,40 @@
+class ZikoIntersectionObserver{
+    constructor(UIElement,callback,{threshold=0,margin=0}={}){
+        this.target=UIElement;
+        this.config={
+            threshold,
+            margin
+        }
+        this.observer=new IntersectionObserver((entries)=>{
+            this.entrie=entries[0];
+            callback(this)
+        },{
+            threshold:this.threshold,
+        })
+    }
+    get ratio(){
+        return this.entrie.intersectionRatio;
+    }
+    get isIntersecting(){
+        return this.entrie.isIntersecting;
+    }
+    setThreshould(threshold){
+        this.config.threshold=threshold;
+        return this;
+    }
+    setMargin(margin){
+        margin=(typeof margin === "number")?margin+"px":margin;
+        this.config.margin=margin;
+        return this;
+    }
+    start(){
+        this.observer.observe(this.target.element);
+        return this;
+    }
+    stop(){
+        return this;
+    }
+}
+
+const WatchIntersection=(UI,callback,config)=>new ZikoIntersectionObserver(UI,callback,config);
+export {WatchIntersection}

package/src/Reactivity/Observer/mutation.js

@@ -0,0 +1,90 @@
+class ZikoMutationObserver {
+    constructor(UIElement, options) {
+      this.UIElement = UIElement;
+      this.options = options || { attributes: true, childList: true, subtree: true };
+      this.observer = null;
+      this.streamingEnabled = true;
+      this.mutationHistory = {
+        attributes: [],
+        childList: [],
+        subtree: [],
+      };
+  
+      this.observeCallback = (mutationsList, observer) => {
+        if (this.streamingEnabled) {
+          for (const mutation of mutationsList) {
+            if (mutation.type === 'attributes') {
+              this.mutationHistory.attributes.push(mutation.target.getAttribute(mutation.attributeName));
+            } else if (mutation.type === 'childList') {
+              this.mutationHistory.childList.push(mutation);
+            } else if (mutation.type === 'subtree') {
+              this.mutationHistory.subtree.push(mutation);
+            }
+          }
+        }
+        if (this.callback) {
+          this.callback(mutationsList, observer);
+        }
+      };
+    }
+  
+    observe(callback) {
+      if(!this.observer) {
+        this.observer = new MutationObserver(this.observeCallback);
+        this.observer.observe(this.UIElement.element, this.options);
+        this.callback = callback;
+        this.streamingEnabled = true;
+      }
+    }
+  
+    pause(options) {
+      if (this.observer) {
+        this.observer.disconnect();
+        if (options) {
+          this.observer.observe(this.UIElement, options);
+        }
+      }
+    }
+  
+    reset(options) {
+      if (this.observer) {
+        this.observer.disconnect();
+        this.observer.observe(this.UIElement, options || this.options);
+      }
+    }
+  
+    clear() {
+      if (this.observer) {
+        this.observer.disconnect();
+        this.observer = null;
+        this.mutationHistory = {
+          attributes: [],
+          childList: [],
+          subtree: [],
+        };
+      }
+      this.streamingEnabled = false;
+      return this;
+    }
+  
+    getMutationHistory() {
+      return this.mutationHistory;
+    }
+  
+    enableStreaming() {
+      this.streamingEnabled = true;
+      return this;
+    }
+  
+    disableStreaming() {
+      this.streamingEnabled = false;
+      return this;
+    }
+  }
+
+const Watch=(UIElement,options={},callback=null)=>{
+    const Observer= new ZikoMutationObserver(UIElement,options);
+    if(callback)Observer.observe(callback);
+    return Observer
+}
+export { Watch }; 

package/src/Reactivity/Observer/resize.js

@@ -0,0 +1,47 @@
+class ZikoResizeObserver{
+    constructor(UIElement,callback){
+        this.target=UIElement;
+        this.contentRect=null;
+        this.observer=new ResizeObserver(()=>{
+           callback(this)
+        })
+    }
+    get BoundingRect(){
+        return this.target.element.getBoundingClientRect();
+    }
+    get width(){
+        return this.BoundingRect.width;
+    }
+    get height(){
+        return this.BoundingRect.height;
+    }
+    get top(){
+        return this.BoundingRect.top;
+    }
+    get bottom(){
+        return this.BoundingRect.bottom;
+    }
+    get right(){
+        return this.BoundingRect.right;
+    }
+    get left(){
+        return this.BoundingRect.left;
+    }
+    get x(){
+        return this.BoundingRect.x;
+    }
+    get y(){
+        return this.boundingRect.y;
+    }
+    start(){
+        this.observer.observe(this.target.element);
+        return this;
+    }
+    stop(){
+        this.observer.unobserve(this.target.element);
+        return this;
+    }
+}
+
+const WatchSize=(UI,callback)=>new ZikoResizeObserver(UI,callback)
+export {WatchSize}

package/src/Reactivity/Use/Contexte/index.js

@@ -0,0 +1 @@
+export * from "./useSuccesifKeys"

package/src/Reactivity/Use/Contexte/useSuccesifKeys.js

@@ -0,0 +1,14 @@
+const useSuccesifKeys=(self,keys=[],callback=()=>{})=>{
+    self.cache.stream.enabled.down=true;
+    const length=keys.length;
+    const LastKeysDown=self.cache.stream.history.down.slice(-length).map(n=>n.key);
+    
+        if(keys.join("")===LastKeysDown.join("")){
+            self.event.preventDefault();
+            callback.call(self,self);
+        }
+    
+}
+export {
+    useSuccesifKeys
+}

package/src/Reactivity/Use/Decorators/index.js

@@ -0,0 +1,4 @@
+export { 
+    useThrottle,
+    useDebounce
+ } from "../../../Time";

package/src/Reactivity/Use/Interactions/index.js

@@ -0,0 +1,4 @@
+export * from "./useChannel";
+export * from "./useEventEmmiter";
+export * from "./useThread";
+export * from "./useBluetooth";

package/src/Reactivity/Use/Interactions/useBluetooth.js

@@ -0,0 +1,48 @@
+import { useEventEmitter } from "./useEventEmmiter";
+class ZikoUseBluetooth{
+    constructor(options={acceptAllDevices:true}){
+        this.options=options;
+        this.__Emitter__=useEventEmitter();
+        if(this.isSupported)this.#init();
+    }   
+    async #init(){
+        this.promise=navigator.bluetooth.requestDevice(this.options).then(device=>this.device=device)
+    }
+    get isSupported(){
+        return !!navigator.bluetooth;
+    }
+    get current(){
+        // Synchrouns Code
+        return this.device;
+    }
+    connect(){
+        this.server=this.device.gatt.connect();
+        this.__Emitter__.emit("ziko:bluetooth-connected");
+        return this;
+    }
+    disconnect(){
+        this.device.gatt.disconnect();
+        this.__Emitter__.emit("ziko:bluetooth-disconnected");
+        return this;
+    }
+    onConnect(callback){
+        this.__Emitter__.on("ziko:bluetooth-connected",callback);
+        return this;
+    }
+    onDisconnect(callback){
+        this.__Emitter__.on("ziko:bluetooth-disconnected",callback);
+        return this;
+    }
+    dispose(){
+
+    }
+    async battery(callback){
+        const batteryService = await this.server.getPrimaryService("battery_service");
+        const batteryLevelCharacteristic = await batteryService.getCharacteristic("battery_level");
+        const batteryLevel = await batteryLevelCharacteristic.readValue();
+        const batteryPercent = await batteryLevel.getUint8(0);
+        callback(batteryPercent)
+    }
+}
+const useBluetooth=(options)=>new ZikoUseBluetooth(options);
+export{ useBluetooth }