ziko 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A versatile JavaScript library offering a rich set of Hyperscript Based UI components, advanced mathematical utilities, interactivity ,animations, client side routing and more ...",
   "keywords": [
     "front-end",

package/src/__ziko__/__state__.js

@@ -4,18 +4,18 @@ export var __State__ = {
     index : 0,
     session_storage : null,
     register: function(state){
-        if(!import.meta.env.SSR && import.meta.env.DEV){
-            if(!this.session) this.session_storage = useSessionStorage('ziko-state', {})
-            const savedValue = this.session_storage.get(this.index)
-            if(!savedValue) this.session_storage.add({[this.index] : state.value});
-            else state.value = savedValue
-        }
-        this.store.set(this.index++, state)
+        // if(!import.meta?.env?.SSR && import.meta?.env?.DEV){
+        //     if(!this.session) this.session_storage = useSessionStorage('ziko-state', {})
+        //     const savedValue = this.session_storage.get(this.index)
+        //     if(!savedValue) this.session_storage.add({[this.index] : state.value});
+        //     else state.value = savedValue
+        // }
+        // this.store.set(this.index++, state)
     },
     update: function(index, value){
-       if(!import.meta.env.SSR && import.meta.env.DEV){
-            this.session_storage.add({[index] : value})
-        } 
+    //    if(!import.meta?.env?.SSR && import.meta?.env?.DEV){
+    //         this.session_storage.add({[index] : value})
+    //     } 
     },
 
 }

package/src/data/converter/index.js

@@ -22,12 +22,12 @@
    svg2imgUrl,
    svg2img
  } from "./svg.js";
- export{
-  obj2str
- } from "./object.js"
- export{
-  arr2str
- } from "./array.js"
+//  export{
+//   obj2str
+//  } from "./object.js"
+//  export{
+//   arr2str
+//  } from "./array.js"
  export{
   json2css
  } from "./css.js"

package/src/data/converter/object.js

@@ -1,5 +1,9 @@
-import { arr2str } from "../index.js";
-import { Complex, mapfun, Matrix } from "../../math/index.js";
+// import { arr2str } from "../index.js";
+// import { Complex, mapfun, Matrix } from "../../math/index.js";
+
+import { Complex } from "../../math/complex/index.js";
+import { Matrix } from "../../math/matrix/index.js";
+import { mapfun } from "../../math/functions/utils/mapfun.js";
 
 // const obj2str=(object)=>{
 //     const recursiveToString = (obj) => {

package/src/hooks/use-reactive.js

@@ -1,4 +1,4 @@
-import { mapfun } from '../math/index.js'
+import { mapfun } from '../math/utils/mapfun.js'
 import { useState } from './use-state.js'
 
 const useReactive = (nested_value) => mapfun(

package/src/hooks/use-state.js

@@ -1,54 +1,56 @@
-import { __init__global__ } from "../__ziko__/index.js";
+// import { __init__global__ } from "../__ziko__/index.js";
 
-if(!globalThis.__Ziko__) __init__global__()
+// if (!globalThis.__Ziko__) __init__global__();
 
 export function useState(initialValue) {
     
-    const {store, index} = __Ziko__.__State__
-    __Ziko__.__State__.register({
-            value : initialValue,
-            subscribers : new Set(),
-            paused : false
-    })
-
-    let current = store.get(index);
+    const state = {
+        value: initialValue,
+        subscribers: new Set(),
+        paused: false,
+    };
 
     function getValue() {
         return {
-            value: current.value,
+            value: state.value,
             isStateGetter: () => true,
-            _subscribe: (fn) => current.subscribers.add(fn),
+            _subscribe: (fn) => {
+                state.subscribers.add(fn);
+                return () => state.subscribers.delete(fn);
+            },
         };
     }
 
     function setValue(newValue) {
-        if (current.paused) return;
+        if (state.paused) return;
+
         if (typeof newValue === "function") {
-            newValue = newValue(current.value);
+            newValue = newValue(state.value);
         }
-        if (newValue !== current.value) {
-            current.value = newValue;
-            current.subscribers.forEach(fn => fn(current.value));
-            __Ziko__.__State__.update(index, newValue)
+
+        if (!Object.is(newValue, state.value)) {
+            state.value = newValue;
+            state.subscribers.forEach((fn) => fn(state.value));
         }
     }
 
     const controller = {
-        pause: () => { current.paused = true; },
-        resume: () => { current.paused = false; },
-        clear: () => { current.subscribers.clear(); },
+        pause: () => { state.paused = true; },
+        resume: () => { state.paused = false; },
+        clear: () => { state.subscribers.clear(); },
         force: (newValue) => {
-            if (typeof newValue === "function") newValue = newValue(current.value);
-            current.value = newValue;
-            current.subscribers.forEach(fn => fn(current.value));
+            if (typeof newValue === "function") {
+                newValue = newValue(state.value);
+            }
+            state.value = newValue;
+            state.subscribers.forEach((fn) => fn(state.value));
         },
-        getSubscribers: () => new Set(current.subscribers),
+        getSubscribers: () => new Set(state.subscribers),
     };
 
     return [getValue, setValue, controller];
 }
 
-
 export const isStateGetter = (arg) => {
-    return typeof arg === 'function' && arg?.()?.isStateGetter?.();
-};
+    return typeof arg === "function" && arg?.()?.isStateGetter?.() === true;
+};

package/src/hooks/use-storage.js

@@ -1,99 +1,118 @@
 import { useIPC } from "./use-ipc.js";
 
 class UseStorage {
-    constructor(storage, globalKey, initialValue, use_channel = true) {
-        this.cache = {
-            storage,
-            globalKey,
-            channel: use_channel ? useIPC(`Ziko:useStorage-${globalKey}`) : null,
-            oldItemKeys: new Set()
-        };
-
-        this.#init(initialValue, use_channel);
-    }
+  static RESERVED_KEYS = new Set([
+    "cache", "items", "set", "add", "remove", "get", "clear", "onStorageUpdated"
+  ]);
 
-    get items() {
-        const raw = this.cache.storage.getItem(this.cache.globalKey);
-        if (!raw) return {};
-        try {
-            return JSON.parse(raw);
-        } catch {
-            return {};
-        }
-    }
+  constructor(storage, globalKey, initialValue, use_channel = true) {
+    this.cache = {
+      storage,
+      globalKey,
+      channel: use_channel ? useIPC(`Ziko:useStorage-${globalKey}`) : null,
+      oldItemKeys: new Set()
+    };
 
-    #maintain() {
-        const items = this.items;
-        this.cache.oldItemKeys.forEach(k => delete this[k]);
-        for (const key in items) {
-            this[key] = items[key];
-            this.cache.oldItemKeys.add(key);
-        }
-    }
-    #init(initialValue, use_channel) {
-        if (use_channel && this.cache.channel) this.cache.channel.on("Ziko-Storage-Updated", () => this.#maintain());
-        if (!initialValue) {
-            this.#maintain();
-            return;
-        }
-        if (this.cache.storage.getItem(this.cache.globalKey)) {
-            const existing = this.items;
-            Object.keys(existing).forEach(k => this.cache.oldItemKeys.add(k));
-            this.#maintain();
-        } 
-        else this.set(initialValue);
-    }
+    this.#init(initialValue, use_channel);
+  }
 
-    set(data) {
-        this.cache.storage.setItem(this.cache.globalKey, JSON.stringify(data));
-        if (this.cache.channel) this.cache.channel.emit("Ziko-Storage-Updated", data);
-        this.#maintain();
-        return this;
+  get items() {
+    const raw = this.cache.storage.getItem(this.cache.globalKey);
+    if (!raw) return {};
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return {};
     }
+  }
 
-    add(data) {
-        this.set({
-            ...this.items,
-            ...data
-        });
-        return this;
+  #maintain() {
+    const currentItems = this.items;
+    const currentKeys = new Set(Object.keys(currentItems));
+
+    // Cleanup keys that were removed
+    this.cache.oldItemKeys.forEach(key => {
+      if (!currentKeys.has(key)) {
+        delete this[key];
+        this.cache.oldItemKeys.delete(key);
+      }
+    });
+
+    // Populate keys from storage onto `this`
+    for (const key in currentItems) {
+      if (!UseStorage.RESERVED_KEYS.has(key)) {
+        this[key] = currentItems[key];
+        this.cache.oldItemKeys.add(key);
+      }
     }
-    remove(...keys) {
-        const items = { ...this.items };
-        keys.forEach(key => {
-            delete items[key];
-            delete this[key];
-            this.cache.oldItemKeys.delete(key);
-        });
-        this.set(items);
-        return this;
+  }
+
+  #init(initialValue, use_channel) {
+    if (use_channel && this.cache.channel) {
+      this.cache.channel.on("Ziko-Storage-Updated", () => this.#maintain());
     }
-    get(key) {
-        return this.items[key];
+
+    const hasStoredData = this.cache.storage.getItem(this.cache.globalKey) !== null;
+
+    if (hasStoredData) {
+      // Key already exists in storage -> Restore data to instance
+      this.#maintain();
+    } else if (initialValue !== undefined) {
+      // Key doesn't exist -> Seed with initialValue
+      this.set(initialValue);
+    } else {
+      // Key doesn't exist and no initialValue provided -> Default to empty
+      this.#maintain();
     }
-    clear() {
-        this.cache.storage.removeItem(this.cache.globalKey);
-        this.cache.oldItemKeys.forEach(k => delete this[k]);
-        this.cache.oldItemKeys.clear();
-        this.#maintain();
-        return this;
+  }
+
+  set(data) {
+    this.cache.storage.setItem(this.cache.globalKey, JSON.stringify(data));
+    if (this.cache.channel) {
+      this.cache.channel.emit("Ziko-Storage-Updated", data);
     }
-    onStorageUpdated(callback) {
-        if (this.cache.channel) {
-            this.cache.channel.on("Ziko-Storage-Updated", callback);
-        }
-        return this;
+    this.#maintain();
+    return this;
+  }
+
+  add(data) {
+    return this.set({
+      ...this.items,
+      ...data
+    });
+  }
+
+  remove(...keys) {
+    const items = { ...this.items };
+    keys.forEach(key => delete items[key]);
+    return this.set(items);
+  }
+
+  get(key) {
+    return this.items[key];
+  }
+
+  clear() {
+    this.cache.storage.removeItem(this.cache.globalKey);
+    this.#maintain();
+    return this;
+  }
+
+  onStorageUpdated(callback) {
+    if (this.cache.channel) {
+      this.cache.channel.on("Ziko-Storage-Updated", callback);
     }
+    return this;
+  }
 }
 
-// factory functions
-const useLocaleStorage = (key, initialValue, use_channel = true) =>
-    new UseStorage(localStorage, key, initialValue, use_channel);
+const useLocalStorage = (key, initialValue, use_channel = true) =>
+  new UseStorage(localStorage, key, initialValue, use_channel);
 
 const useSessionStorage = (key, initialValue, use_channel = true) =>
-    new UseStorage(sessionStorage, key, initialValue, use_channel);
+  new UseStorage(sessionStorage, key, initialValue, use_channel);
 
 export {
-    useLocaleStorage,
-    useSessionStorage
-};
+  useLocalStorage,
+  useSessionStorage
+};

package/src/math/functions/mapfun/index.d.ts

@@ -1,4 +1,4 @@
-import { Complex } from "../../../src/math/index.js";
+import { Complex } from "../../../src/math/Complex/index.js";
 import { Matrix } from "../../../src/math/matrix/index.js";
 
 /**

package/src/math/index.d.ts.txt

@@ -0,0 +1,5 @@
+export type * from './complex/index.d.ts'
+// export type * from './time'
+// export type * from './router'
+// export type * from './hooks'
+// export type * from './data'

package/src/math/index.js

@@ -16,11 +16,11 @@
 // }
 export * from "./const.js"
 export * from "./functions/index.js"
-export * from "./complex"
-export * from "./matrix"
+export * from "./complex/index.js"
+export * from "./matrix/index.js"
 // export * from "./discret"
-export * from "./random"
-export * from "./utils"
+export * from "./random/index.js"
+// export * from "./utils/index.js"  // To Check
 // export * from "./statistics"
 // export default Math;
 

package/src/math/utils/index.js

@@ -1,102 +1,108 @@
-// import { mapfun } from "../mapfun/index.js";
-// import { 
-//     add,
-//     sub,
-//     mul,
-//     div,
-//     modulo
-//  } from "./arithmetic.js";
-import {
-    zeros,
-    ones,
-    nums,
-    // norm,
-    // lerp,
-    // map,
-    // clamp,
-    arange,
-    linspace,
-    logspace,
-    geomspace
-} from "../signal/functions.js"
+export * from './arithmetic.js'
+export * from './checkers.js'
+export * from './comparaison.js'
+export * from './conversions.js'
+export * from './discret.js'
+// export * from './mapfun.js'
+// // import { mapfun } from "../mapfun/index.js";
+// // import { 
+// //     add,
+// //     sub,
+// //     mul,
+// //     div,
+// //     modulo
+// //  } from "./arithmetic.js";
 // import {
-//     deg2rad,
-//     rad2deg
-// } from "./conversions.js"
+//     zeros,
+//     ones,
+//     nums,
+//     // norm,
+//     // lerp,
+//     // map,
+//     // clamp,
+//     arange,
+//     linspace,
+//     logspace,
+//     geomspace
+// } from "../signal/functions.js"
+// // import {
+// //     deg2rad,
+// //     rad2deg
+// // } from "./conversions.js"
+// // import{
+// //     sum,
+// //     prod,
+// //     accum
+// // } from "../statistics/index.js"
 // import{
-//     sum,
-//     prod,
-//     accum
-// } from "../statistics/index.js"
-import{
-    inRange,
-    isApproximatlyEqual
-} from "./checkers.js"
-import{
-    cartesianProduct,
-    ppcm,
-    pgcd
-} from "./discret.js"
-const Utils={
-    // add,
-    // sub,
-    // mul,
-    // div,
-    // modulo,
+//     inRange,
+//     isApproximatlyEqual
+// } from "./checkers.js"
+// import{
+//     cartesianProduct,
+//     ppcm,
+//     pgcd
+// } from "./discret.js"
+// const Utils={
+//     // add,
+//     // sub,
+//     // mul,
+//     // div,
+//     // modulo,
 
-    zeros,
-    ones,
-    nums,
-    // norm,
-    // lerp,
-    // map,
-    // clamp,
-    arange,
-    linspace,
-    logspace,
-    geomspace,
+//     zeros,
+//     ones,
+//     nums,
+//     // norm,
+//     // lerp,
+//     // map,
+//     // clamp,
+//     arange,
+//     linspace,
+//     logspace,
+//     geomspace,
 
-    // sum,
-    // prod,
-    // accum,
+//     // sum,
+//     // prod,
+//     // accum,
 
-    cartesianProduct,
-    ppcm,
-    pgcd,
+//     cartesianProduct,
+//     ppcm,
+//     pgcd,
 
-    // deg2rad,
-    // rad2deg,
+//     // deg2rad,
+//     // rad2deg,
 
-    inRange,
-    isApproximatlyEqual
-}
-export {
-    // mapfun,
-    Utils,
-    zeros,
-    ones,
-    nums,
-    // sum,
-    // prod,
-    // add,
-    // mul,
-    // sub,
-    // div,
-    // modulo,
-    // rad2deg,
-    // deg2rad,
-    arange,
-    linspace,
-    logspace,
-    geomspace,
-    // norm,
-    // lerp,
-    // map,
-    // clamp,
-    pgcd,
-    ppcm,
-    isApproximatlyEqual,
-    inRange,
-    cartesianProduct,
-  };
+//     inRange,
+//     isApproximatlyEqual
+// }
+// export {
+//     // mapfun,
+//     Utils,
+//     zeros,
+//     ones,
+//     nums,
+//     // sum,
+//     // prod,
+//     // add,
+//     // mul,
+//     // sub,
+//     // div,
+//     // modulo,
+//     // rad2deg,
+//     // deg2rad,
+//     arange,
+//     linspace,
+//     logspace,
+//     geomspace,
+//     // norm,
+//     // lerp,
+//     // map,
+//     // clamp,
+//     pgcd,
+//     ppcm,
+//     isApproximatlyEqual,
+//     inRange,
+//     cartesianProduct,
+//   };
  

package/src/math/utils/mapfun.js

@@ -1,4 +1,4 @@
-const mapfun=(fun,...X)=>{
+export const mapfun=(fun,...X)=>{
     const Y=X.map(x=>{
         if(
             x===null||
@@ -40,4 +40,3 @@ const mapfun=(fun,...X)=>{
     });
    return Y.length==1? Y[0]: Y; 
 }
-export {mapfun}

package/src/math/index.d.ts

@@ -1,5 +0,0 @@
-export type * from './math'
-export type * from './time'
-export type * from './router'
-export type * from './hooks'
-export type * from './data'