ziko 0.0.11 → 0.0.13

package/src/reactivity/hooks/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/hooks/Decorators/index.js

@@ -0,0 +1,6 @@
+export { useType } from "./type";
+
+export { 
+    useThrottle,
+    useDebounce
+ } from "../../../time";

package/src/reactivity/hooks/Decorators/time.js

@@ -0,0 +1,17 @@
+const useDebounce=(fn,delay=1000)=>{
+    let id;
+    return(...args)=>id?clearTimeout(id):setTimeout(()=>fn(...args),delay)
+}
+const useThrottle=(fn,delay)=>{
+    let lastTime=0;
+    return (...args)=>{
+        const now=new Date().getTime()
+        if(now-lastTime<delay)return;
+        lastTime=now;
+        fn(...args); 
+    }
+}
+export{
+    useDebounce,
+    useThrottle
+}

package/src/reactivity/hooks/Decorators/type.js

@@ -0,0 +1,88 @@
+function useType(func, ...expectedTypes) {
+  const argNames = func.toString()
+    .match(/\(([^)]*)\)/)[1]
+    .split(',')
+    .map(arg => arg.trim());
+  return function(...args) {
+    const lastExpectedType = expectedTypes[expectedTypes.length - 1];
+    for (let i = 0; i < args.length; i++) {
+      const isRestParam = i >= expectedTypes.length;
+      const expectedType = isRestParam ? lastExpectedType : expectedTypes[i];
+      const arg = args[i];
+      const argName = isRestParam ? `${argNames[argNames.length - 1]}[${i - expectedTypes.length + 1}]` : argNames[i] || `Argument ${i + 1}`;
+      let isValid = false;
+      if(typeof expectedType === "object"){
+        if (expectedType.or) {
+          for (const type of expectedType.types) {
+            if (checkTypeOrInstance(type, arg)) {
+              isValid = true;
+              break;
+            }
+          }
+        }
+        if (expectedType.nor) {
+          for (const type of expectedType.types) {
+            if (checkTypeOrInstance(type, arg)) {
+              isValid = false;
+              break;
+            }
+            isValid = true
+          }
+        } 
+        else if (expectedType.not) isValid = !checkTypeOrInstance(expectedType.type, arg);
+      }
+      else isValid = checkTypeOrInstance(expectedType, arg);
+      // Should Fix Nor error Message
+      if (!isValid) {
+        // const expectedTypeName = typeof expectedType === 'object'
+        //   ? expectedType.or
+        //     ? expectedType.types.map(type => (typeof type === 'string' ? type : type.name)).join(' or ')
+        //     : expectedType.not
+        //     ? `not ${typeof expectedType.type === 'string' ? expectedType.type : expectedType.type.name}`
+        //     : Array.isArray(expectedType)
+        //     ? `[${expectedType.map(type => (typeof type === 'string' ? type : type.name)).join(', ')}]`
+        //     : `{${Object.entries(expectedType).map(([key, type]) => `${key}: ${typeof type === 'string' ? type : type.name}`).join(', ')}}`
+        //   : typeof expectedType === 'string'
+        //   ? expectedType
+        //   : expectedType.name;
+        // throw new TypeError(`${argName} should be of type ${expectedTypeName}`);
+        throw new TypeError("jjj")
+      }
+    }
+    return func(...args);
+  };
+}
+
+function useOr(...types) {
+  return { or: true, types };
+}
+function useNot(type) {
+  return { not: true, type };
+}
+function useNor(...types){
+  return { nor: true, types}
+}
+const checkTypeOrInstance = (type, arg) => {
+  if (typeof type === 'string') return typeof arg === type;
+  else if (type instanceof Function) return arg instanceof type;
+  else if (Array.isArray(type)) 
+    return (!Array.isArray(arg) || arg.length !== type.length)? false: arg.every((item, index) => checkTypeOrInstance(type[index], item));  
+  else if (typeof type === 'object' && !Array.isArray(type)) 
+    return (typeof arg !== 'object' || arg === null)? false : Object.keys(type).every(key => key in arg && checkTypeOrInstance(type[key], arg[key]))  
+  return false;
+};
+// globalThis.useType = useType
+// globalThis.useNot = useNot
+// globalThis.useOr = useOr
+
+// function add(a, b = 0){
+//   return a+b
+//  }
+ 
+// add = useType(add,"number",useNor("string","number"))
+ 
+// console.log(add(1))
+
+export{
+  useType
+}

package/src/reactivity/hooks/Interactions/index.js

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

package/src/reactivity/hooks/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 }

package/src/reactivity/hooks/Interactions/useChannel.js

@@ -0,0 +1,50 @@
+import { Random } from "../../../math/random";
+class ZikoUseChannel{
+    constructor(name=""){
+        this.channel=new BroadcastChannel(name);
+        this.EVENTS_DATAS_PAIRS=new Map();
+        this.EVENTS_HANDLERS_PAIRS=new Map();
+        this.LAST_RECEIVED_EVENT="";
+        this.UUID="ziko-channel"+Random.string(10);
+        this.SUBSCRIBERS=new Set([this.UUID]);
+    }
+    get broadcast(){
+        // update receiver
+        return this;
+    }
+    emit(event, data){
+        this.EVENTS_DATAS_PAIRS.set(event,data)
+        this.#maintainEmit(event);
+        return this;
+    }
+    on(event,handler=console.log){
+        this.EVENTS_HANDLERS_PAIRS.set(event,handler);
+        this.#maintainOn()
+        return this;
+    }
+    #maintainOn(){
+        this.channel.onmessage = (e) => {
+            this.LAST_RECEIVED_EVENT=e.data.last_sended_event;
+            const USER_ID=e.data.userId;
+            this.SUBSCRIBERS.add(USER_ID)
+            const Data=e.data.EVENTS_DATAS_PAIRS.get(this.LAST_RECEIVED_EVENT)
+            const Handler=this.EVENTS_HANDLERS_PAIRS.get(this.LAST_RECEIVED_EVENT)
+            if(Data && Handler)Handler(Data)
+          };
+          return this;
+    }
+    #maintainEmit(event){
+        this.channel.postMessage({
+            EVENTS_DATAS_PAIRS:this.EVENTS_DATAS_PAIRS,
+            last_sended_event:event,
+            userId:this.UUID
+        });
+        return this;
+    }
+    close(){
+        this.channel.close();
+        return this;
+    }
+}
+const useChannel=name=>new ZikoUseChannel(name);
+export{ useChannel }

package/src/reactivity/hooks/Interactions/useEventEmmiter.js

@@ -0,0 +1,64 @@
+class ZikoUseEventEmitter {
+    constructor() {
+      this.events = {};
+      this.maxListeners = 10; 
+    }
+    on(event, listener) {
+      if (!this.events[event]) {
+        this.events[event] = [];
+      }
+      this.events[event].push(listener);  
+      if (this.events[event].length > this.maxListeners) {
+        console.warn(`Warning: Possible memory leak. Event '${event}' has more than ${this.maxListeners} listeners.`);
+      }
+    }
+    once(event, listener) {
+      const onceListener = (data) => {
+        this.off(event, onceListener); // Remove the listener after it's been called
+        listener(data);
+      };
+      this.on(event, onceListener);
+    }
+  
+    off(event, listener) {
+      const listeners = this.events[event];
+      if (listeners) {
+        const index = listeners.indexOf(listener);
+        if (index !== -1) {
+          listeners.splice(index, 1);
+        }
+      }
+    }
+  
+    emit(event, data) {
+      const listeners = this.events[event];
+      if (listeners) {
+        listeners.forEach(listener => {
+          listener(data);
+        });
+      }
+    }
+  
+    clear(event) {
+      if (event) {
+        delete this.events[event];
+      } else {
+        this.events = {};
+      }
+    }
+  
+    setMaxListener(event, max) {
+      this.maxListeners = max;
+    }
+  
+    removeAllListeners(event) {
+      if (event) {
+        this.events[event] = [];
+      } else {
+        this.events = {};
+      }
+    }
+  }
+
+const useEventEmitter=()=>new ZikoUseEventEmitter()
+export{useEventEmitter}

package/src/reactivity/hooks/Interactions/useThread.js

@@ -0,0 +1,44 @@
+class ZikoUseThreed {
+    #workerContent;
+    constructor() {
+        this.#workerContent = (
+            function (msg) {
+                try {
+                    const func = new Function("return " + msg.data.fun)();
+                    let result = func();
+                    postMessage({ result });
+                } catch (error) {
+                    postMessage({ error: error.message });
+                } finally {
+                    if (msg.data.close) self.close();
+                }
+            }
+        ).toString();
+        this.blob = new Blob(["this.onmessage = " + this.#workerContent], { type: "text/javascript" });
+        this.worker = new Worker(window.URL.createObjectURL(this.blob));
+    }
+    call(func, callback, close = true) {
+        this.worker.postMessage({
+            fun: func.toString(),
+            close
+        });
+        this.worker.onmessage = function (e) {
+            if (e.data.error) {
+                console.error(e.data.error);
+            } else {
+                callback(e.data.result);
+            }
+        };
+        return this;
+    }
+}
+
+const useThread = (func, callback , close) => {
+    const T = new ZikoUseThreed();
+    if (func) {
+        T.call(func, callback , close);
+    }
+    return T;
+}
+
+export { useThread };

package/src/reactivity/hooks/Sensors/index.js

@@ -0,0 +1,2 @@
+export * from "./useBattery";
+export * from "./useGeolocation"

package/src/reactivity/hooks/Sensors/useBattery.js

@@ -0,0 +1,36 @@
+class ZikoUseBattery{
+    constructor(){
+        if(this.isSupported)this.#init();
+    }   
+    async #init(){
+        this.__Battery__=await navigator.getBattery(); 
+    }
+    get isSupported(){
+        return !!navigator.getBattery;
+    }
+    get current(){
+        // Synchrouns Code
+        const {
+            level,
+            charging,
+            chargingTime,
+            dischargingTime
+        }=this.__Battery__;
+        return{
+            level,
+            charging,
+            chargingTime,
+            dischargingTime
+        }
+    }
+    onChargingChange(callback){
+        this.__Battery__?.addEventListener("chargingchange",callback);
+        return this;
+    }
+    onLevelChange(callback){
+        this.__Battery__?.addEventListener("levelchange",callback);
+        return this;
+    }
+}
+const useBattery=()=>new ZikoUseBattery();
+export{ useBattery }

package/src/reactivity/hooks/Sensors/useGeolocation.js

@@ -0,0 +1,17 @@
+class ZikoUseGeolocation{
+    constructor(){
+        if(this.isSupported)this.#init();
+    }   
+    async #init(){
+        navigator.geolocation.getCurrentPosition(e=>this.__Geolocation__=e)
+    }
+    get isSupported(){
+        return !!navigator.geolocation;
+    }
+    get current(){
+        // Synchrouns Code
+        return this.__Geolocation__;
+    }
+}
+const useGeolocation=()=>new ZikoUseGeolocation();
+export{ useGeolocation }

package/src/reactivity/hooks/Storage/index.js

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

package/src/reactivity/hooks/Storage/useStorage.js

@@ -0,0 +1,73 @@
+// To do : remove old items
+import { useChannel } from "../Interactions";
+class ZikoUseStorage{
+    constructor(storage,globalKey,initialValue){
+        this.cache={
+            storage,
+            globalKey,
+            channel:useChannel(`Ziko:useStorage-${globalKey}`),
+            oldItemKeys:new Set()
+        }
+        this.#init(initialValue);
+        this.#maintain();
+    }
+    get items(){
+        return JSON.parse(this.cache.storage[this.cache.globalKey]??null);
+    }
+    #maintain() {
+        for(let i in this.items)Object.assign(this, { [[i]]: this.items[i] });
+    }
+    #init(initialValue){
+        this.cache.channel=useChannel(`Ziko:useStorage-${this.cache.globalKey}`);
+        this.cache.channel.on("Ziko-Storage-Updated",()=>this.#maintain());
+        if(!initialValue)return;
+        if(this.cache.storage[this.cache.globalKey]){
+            Object.keys(this.items).forEach(key=>this.cache.oldItemKeys.add(key));
+            console.group("Ziko:useStorage")
+            console.warn(`Storage key '${this.cache.globalKey}' already exists. we will not overwrite it.`);
+            console.info(`%cWe'll keep the existing data.`,"background-color:#2222dd; color:gold;");
+            console.group("")
+        }
+        else this.set(initialValue);
+    }
+    set(data){
+        this.cache.storage.setItem(this.cache.globalKey,JSON.stringify(data));
+        this.cache.channel.emit("Ziko-Storage-Updated",{});
+        Object.keys(data).forEach(key=>this.cache.oldItemKeys.add(key));
+        this.#maintain();
+        return this
+    }
+    add(data){
+        const db={
+            ...this.items,
+            ...data
+        }
+        this.cache.storage.setItem(this.cache.globalKey,JSON.stringify(db));
+        this.#maintain();
+        return this;
+    }
+    remove(...keys){
+        const db={...this.items};
+        for(let i=0;i<keys.length;i++){
+            delete db[keys[i]];
+            delete this[keys[i]];
+        }
+        this.set(db);
+        return this;
+    }
+    get(key){
+        return this.items[key];
+    }
+    clear(){
+        this.cache.storage.removeItem(this.cache.globalKey);
+        this.#maintain();
+        return this;
+    }
+
+}
+const useLocaleStorage=(key,initialValue)=>new ZikoUseStorage(localStorage,key,initialValue);
+const useSessionStorage=(key,initialValue)=>new ZikoUseStorage(sessionStorage,key,initialValue);
+export{
+    useLocaleStorage,
+    useSessionStorage
+}

package/src/reactivity/hooks/UI/index.js

@@ -0,0 +1,5 @@
+export * from "./useStyle";
+export * from "./useTheme";
+export * from "./useTitle";
+export * from "./useFavIcon";
+export * from "./useMediaQuery"

package/src/reactivity/hooks/UI/useCssText.js

@@ -0,0 +1,21 @@
+class ZikoUseCssText{
+    constructor(css){
+        this.#init();
+        this.set(css);
+    }
+    #init(){     
+        // this.__FavIcon__=document.querySelector("link[rel*='icon']") || document?.createElementt('link');   
+        // this.__FavIcon__.type = 'image/x-icon';
+        // this.__FavIcon__.rel = 'shortcut icon';
+        return this;
+    }
+    set(cssText){
+        // if(href!==this.__FavIcon__.href){
+        //     this.__FavIcon__.href=href;
+        //     if(this.cache.Emitter)this.cache.Emitter.emit("ziko:favicon-changed");
+        // }
+        return this;
+    }
+}
+const useFavIcon=(FavIcon,useEventEmitter)=>new ZikoUseFavIcon(FavIcon,useEventEmitter);
+export{ useFavIcon }

package/src/reactivity/hooks/UI/useFavIcon.js

@@ -0,0 +1,38 @@
+import { useEventEmitter } from "../Interactions/useEventEmmiter";
+class ZikoUseFavIcon{
+    constructor(FavIcon,useEventEmitter=true){
+        this.#init();
+        this.cache={
+            Emitter:null
+        }
+        if(useEventEmitter)this.useEventEmitter();
+        this.set(FavIcon);
+    }
+    #init(){     
+        this.__FavIcon__=document.querySelector("link[rel*='icon']") || document?.createElement('link');   
+        this.__FavIcon__.type = 'image/x-icon';
+        this.__FavIcon__.rel = 'shortcut icon';
+        return this;
+    }
+    set(href){
+        if(href!==this.__FavIcon__.href){
+            this.__FavIcon__.href=href;
+            if(this.cache.Emitter)this.cache.Emitter.emit("ziko:favicon-changed");
+        }
+        return this;
+    }
+    get current(){
+        return document.__FavIcon__.href;
+    }
+    onChange(callback){
+        if(this.cache.Emitter)this.cache.Emitter.on("ziko:favicon-changed",callback);
+        return this;
+    }
+    useEventEmitter(){
+        this.cache.Emitter=useEventEmitter();
+        return this;
+    }
+
+}
+const useFavIcon=(FavIcon,useEventEmitter)=>new ZikoUseFavIcon(FavIcon,useEventEmitter);
+export{ useFavIcon }

package/src/reactivity/hooks/UI/useMediaQuery.js

@@ -0,0 +1,43 @@
+/*
+ [
+            {
+                query: '(min-width: 600px)',
+                callback: () => console.log(1)
+            },
+            {
+                query: '(max-width: 300px)',
+                callback: () => console.log(2)
+            }
+        ]
+*/
+class ZikoUseMediaQuery {
+    constructor(mediaQueryRules=[],fallback=()=>{}) {
+        this.mediaQueryRules = mediaQueryRules;
+        this.fallback = fallback;
+        this.lastCalledCallback = null;
+        this.init();
+    }
+
+    init() {
+        this.mediaQueryRules.forEach(({ query, callback }) => {
+            const mediaQueryList = globalThis.matchMedia(query);
+            const checkMatches = () => {
+                const anyMatch = this.mediaQueryRules.some(({ query }) => globalThis.matchMedia(query).matches);
+                if (mediaQueryList.matches) {
+                    callback();
+                    this.lastCalledCallback = callback;
+                } else if (!anyMatch && this.lastCalledCallback !== this.fallback) {
+                    this.fallback();
+                    this.lastCalledCallback = this.fallback;
+                }
+            };
+            checkMatches()
+            mediaQueryList.addListener(checkMatches);
+        });
+    }
+}
+
+const useMediaQuery = (mediaQueryRules,fallback) => new ZikoUseMediaQuery(mediaQueryRules,fallback);
+export {
+    useMediaQuery
+};