ziko 0.49.4 → 0.49.6

package/src/use/use-storage.js.txt

@@ -0,0 +1,73 @@
+// To do : remove old items
+import { useChannel } from "./use-channel.js";
+class UseStorage{
+    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 UseStorage(localStorage,key,initialValue);
+const useSessionStorage=(key,initialValue)=>new UseStorage(sessionStorage,key,initialValue);
+export{
+    useLocaleStorage,
+    useSessionStorage
+}

package/src/use/use-thread.js

@@ -1,4 +1,4 @@
-class ZikoUseThreed {
+class UseThreed {
     #workerContent;
     constructor() {
         this.#workerContent = (
@@ -34,7 +34,7 @@ class ZikoUseThreed {
 }
 
 const useThread = (func, callback , close) => {
-    const T = new ZikoUseThreed();
+    const T = new UseThreed();
     if (func) {
         T.call(func, callback , close);
     }

package/types/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export type * from './use-channel.d.ts'
+export type * from './use-state.d.ts'
+export type * from './use-derived.d.ts'
+export type * from './use-reactive.d.ts'

package/types/hooks/use-channel.d.ts

@@ -0,0 +1,12 @@
+export declare class UseChannel {
+    emit(event: string, data: any, rooms?: string[]): this;
+    on(event: string, handler: (data: any) => void, rooms?: string | string[]): this;
+    off(event: string, handler: (data: any) => void): this;
+    once(event: string, handler: (data: any) => void, rooms?: string | string[]): this;
+    join(...rooms: string[]): this;
+    leave(...rooms: string[]): this;
+    close(): this;
+
+}
+
+export declare const useChannel: (name?: string) => UseChannel;

package/types/hooks/use-derived.d.ts

@@ -0,0 +1,14 @@
+export function useDerived<T>(
+    deriveFn: (...values: any[]) => T,
+    sources: Array<
+        () => {
+            value: any;
+            isStateGetter: () => true;
+            _subscribe: (fn: (value: any) => void) => void;
+        }
+    >
+): () => {
+    value: T;
+    isStateGetter: () => true;
+    _subscribe: (fn: (value: T) => void) => void;
+};

package/types/hooks/use-reactive.d.ts

@@ -0,0 +1,14 @@
+import { mapfun, MapfunResult } from "../math/utils/mapfun.d.ts";
+import { useState } from "./use-state.d.ts";
+
+export function useReactive<
+    T
+>(
+    nested_value: T
+): MapfunResult<
+    (n: any) => {
+        get: ReturnType<typeof useState<any>>[0];
+        set: ReturnType<typeof useState<any>>[1];
+    },
+    T
+>;

package/types/hooks/use-state.d.ts

@@ -0,0 +1,25 @@
+export function useState<T>(
+    initialValue: T
+): [
+    /** getter function */
+    () => {
+        value: T;
+        isStateGetter: () => true;
+        _subscribe: (fn: (value: T) => void) => void;
+    },
+
+    /** setter function */
+    (newValue: T | ((prev: T) => T)) => void,
+
+    /** controller */
+    {
+        pause: () => void;
+        resume: () => void;
+        clear: () => void;
+        force: (newValue: T | ((prev: T) => T)) => void;
+        getSubscribers: () => Set<(value: T) => void>;
+    }
+];
+
+/** check if argument is a state getter */
+export function isStateGetter(arg: any): boolean;

package/types/index.d.ts

@@ -1,2 +1,3 @@
 export type * from './math'
-export type * from './time'
+export type * from './time'
+export type * from './hooks'

package/src/math/absract.js

@@ -1 +0,0 @@
-export default class ZikoMath {}

package/src/use/use-channel.js

@@ -1,50 +0,0 @@
-import { Random } from "../math/random/index.js";
-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 }