ziko 0.51.1 → 0.53.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.51.1",
+  "version": "0.53.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/{__helpers__ → helpers}/register/index.js

@@ -1,5 +1,5 @@
 import { register_to_class } from "./register-to-class.js";
-import { register_to_instance } from "./register-to-instance"; // Not Overridable
+import { register_to_instance } from "./register-to-instance.js"; // Not Overridable
 export const register = (target, ...mixins) => {
   console.log(target)
   // return register_to_class(target, ...mixins)

package/src/hooks/use-ipc.js

@@ -1,5 +1,3 @@
-import { Random } from "../math/random/index.js";
-
 class UseIPC {
     #channel;
     #eventData;
@@ -11,7 +9,7 @@ class UseIPC {
         this.#channel = new BroadcastChannel(name);
         this.#eventData = new Map();
         this.#handlers = new Map(); // Map<event, Array<{fn, rooms}>>
-        this.#uuid = "ziko-channel:" + Random.string(10);
+        this.#uuid = "ziko-channel:" + (Math.random()*10e16);  // To Be Replaced by UUID
         this.#subscribers = new Set([this.#uuid]);
         this.#currentRooms = new Set(); 
         this.#channel.addEventListener("message", (e) => {

package/src/math/adapted/index.js

@@ -0,0 +1,7 @@
+export const adapted_cos = x =>{
+    if(x.isComplex?.()) return new x.constructor(
+            Math.cos(x.a)*Math.cosh(x.b),
+            -(Math.sin(x.a)*Math.sinh(x.b))
+    );
+    return Math.cos(x)
+}

package/src/math/complex/index.js

@@ -41,8 +41,8 @@ class Complex{
                 this.a=a.b/tan(a.phi);
             }
             else if(("z" in a && "phi" in a)){
-                this.a=a.z*cos(a.phi);
-                this.a=a.z*sin(a.phi);
+                this.a = +a.z*cos(a.phi).toFixed(15);
+                this.b = +a.z*sin(a.phi).toFixed(15);
             }
         }
         else if(typeof(a)==="number"&&typeof(b)==="number"){
@@ -50,6 +50,9 @@ class Complex{
             this.b = +b.toFixed(32);
         }
     }
+    get __mapfun__(){
+        return true
+    }
     isComplex(){
         return true
     }
@@ -66,7 +69,7 @@ class Complex{
         return str;
     }
       
-    get clone() {
+    clone() {
         return new Complex(this.a, this.b);
     }
     get z(){
@@ -143,19 +146,19 @@ class Complex{
         return [this.z, this.phi];
     }
     static add(c,...z) {
-        return c.clone.add(...z);
+        return c.clone().add(...z);
     }
     static sub(c,...z) {
-        return c.clone.sub(...z);
+        return c.clone().sub(...z);
     }
     static mul(c,...z) {
-        return c.clone.mul(...z);
+        return c.clone().mul(...z);
     }
     static div(c,...z) {
-        return c.clone.div(...z);
+        return c.clone().div(...z);
     }
     static pow(z,n){
-        return z.clone.pow(n);
+        return z.clone().pow(n);
     }
     static xpowZ(x){
         return complex((x**this.a)*cos(this.b*ln(x)),(x**this.a)*sin(this.b*ln(x)));

package/src/math/functions/helper.js

@@ -1,30 +1,81 @@
 const {PI, cos, sin, tan, acos, asin, atan, cosh, sinh, tanh, acosh, asinh, atanh, log} = Math
 export let Fixed={
-    cos,
-    sin,
-    tan,
+    cos : x=> {
+        if(x.isComplex?.()) return new x.constructor(
+            cos(x.a)*cosh(x.b),
+            -(sin(x.a)*sinh(x.b))
+        );
+        return cos(x)
+    },
+    sin : x=>{
+        if(x?.isComplex) return new x.constructor(
+            sin(x.a)*cosh(x.b),
+            cos(x.a)*sinh(x.b)
+        );
+        return sin(x)
+    },
+    tan : x=>{
+        if(x?.isComplex){
+            const DEN = cos(2*x.a)+cosh(2*x.b);
+            return new x.constructor(
+                sin(2*x.a)/DEN,
+                sinh(2*x.b)/DEN
+            );
+        } 
+        return tan(x) 
+    },
     sinc: x => sin(PI*x)/(PI*x),
     sec: x => 1/cos(x),
     csc: x => 1/sin(x),
     cot: x => 1/tan(x),
-    acos,
-    asin,
-    atan,
+    acos: x=>{
+        if(x?.isComplex) return 
+        return sin(x)
+    },
+    asin: x=>{
+        if(x?.isComplex) return 
+        return sin(x)
+    },
+    atan: x=>{
+        if(x?.isComplex) return 
+        return sin(x)
+    },
     acot: x => PI/2-atan(x),
-    cosh,
-    sinh,
-    tanh,
+    cosh: x=>{
+        if(x?.isComplex) return new x.constructor(
+            cosh(x.a)*cos(x.b),
+            sinh(x.a)*sin(x.b)
+        ); 
+        return cosh(x)
+    },
+    sinh: x=>{
+        if(x?.isComplex) return new x.constructor(
+            sinh(x.a)*cos(x.b),
+            cosh(x.a)*sin(x.b)
+        ); 
+        return sinh(x)
+    },
+    tanh: x=>{
+        if(x?.isComplex){
+            const DEN=cosh(2*a)+cos(2*b);
+            return new x.constructor(
+                sinh(2*a)/DEN,
+                sin(2*b)/DEN
+            )
+        } 
+        return tanh(x)
+    },
     coth: n => (1/2*log((1+n)/(1-n))),
     acosh,
     asinh,
     atanh,
 }
 
-Fixed = new Proxy(Fixed, {
-    get(target, prop) {
-        if(prop in target){
-            return x => + target[prop](x).toFixed(15);
-        }
-        return undefined;
-    }
-})
+// Fixed = new Proxy(Fixed, {
+//     get(target, prop) {
+//         if(prop in target){
+//             return x => + target[prop](x).toFixed(15);
+//         }
+//         return undefined;
+//     }
+// })

package/src/math/functions/index.js

@@ -1,9 +1,10 @@
 import { Fixed } from "./helper.js";
-import { mapfun } from "../utils/mapfun.js";
+import { mapfun } from "../mapfun/index.js";
 import { 
     min,
     max 
-}from "../statistics/index.js";
+}
+from "../statistics/index.js";
 
 const abs=(...x)=>mapfun(Math.abs,...x);
 const sqrt=(...x)=>mapfun(Math.sqrt,...x);

package/src/math/functions/primitives/index.js

@@ -0,0 +1,355 @@
+import { mapfun } from '../../mapfun/index.js';
+
+export const abs = (...x) => mapfun(
+    x =>{
+        if(x.isComplex?.()) return x.z;
+        return Math.abs(x)
+    },
+    ...x
+)
+
+export const pow = (...x) => {
+    const n = x.pop();
+    return mapfun(
+        x => {
+            if(x.isComplex?.()) {
+                if(n.isComplex?.()) return new x.constructor({
+                    z: Math.exp(n.a * Math.log(x.z) - n.b * x.phi),
+                    phi: n.b * Math.log(x.z) + n.a * x.phi
+                })
+                return new x.constructor({z: x.z ** n, phi: x.phi * n});
+            }
+            if(n.isComplex?.()) return new x.constructor({
+                    z: Math.exp(n.a * Math.log(x)),
+                    phi: n.b * Math.log(x)
+                })
+            return Math.pow(x, n)
+        },
+        ...x
+    )
+}
+
+export const sqrt = (...x) => mapfun(
+    x=>{
+        if(x.isComplex?.()) 
+            return new x.constructor({z: x.z**(1/2), phi: x.phi/2})
+        return Math.sqrt(x);
+    },
+    ...x
+);
+
+export const cbrt = (...x) => mapfun(
+    x=>{
+        if(x.isComplex?.()) 
+            return new x.constructor({z: x.z**(1/3), phi: x.phi/3})
+        return Math.sqrt(x);
+    },
+    ...x
+);
+
+export const nthr = (...x) => {
+    const n = x.pop();
+    return mapfun(
+        x => {
+            if(x.isComplex?.()) return new x.constructor({z: x.z ** 1/n, phi: x.phi / n});
+            return x**(1/n)
+        },
+        ...x
+    )
+}
+
+export const croot = (...x) =>{
+    const z = x.pop()
+    return mapfun(
+        x => {
+            if(x.isComplex?.()) return null
+            return null
+        },
+        ...x
+    )
+}
+
+export const exp = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.exp(x.a) * Math.cos(x.b),
+            Math.exp(x.a) * Math.sin(x.b)
+        );
+        return Math.ln(x)
+    }
+    ,...x
+);
+
+export const ln = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.log(x.z),
+            x.phi
+        );
+        return Math.ln(x)
+    }
+    ,...x
+);
+
+export const sign = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()){
+            const {z, phi} = x;
+            if(z===0) return new x.constructor(0, 0);
+            return new x.constructor({z:1, phi})
+        }
+        return Math.sign(x)
+    }
+    ,...x
+);
+
+export const floor = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.floor(x.a),
+            Math.floor(x.b)
+        )
+        return Math.floor(x)
+    },
+    ...x
+)
+export const ceil = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.ceil(x.a),
+            Math.ceil(x.b)
+        )
+        return Math.ceil(x)
+    },
+    ...x
+)
+export const round = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.round(x.a),
+            Math.round(x.b)
+        )
+        return Math.round(x)
+    },
+    ...x
+)
+
+export const trunc = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.trunc(x.a),
+            Math.trunc(x.b)
+        )
+        return Math.trunc(x)
+    },
+    ...x
+)
+
+export const fract = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            x.a - Math.trunc(x.a),
+            x.b - Math.trunc(x.b)
+        )
+        return x - Math.trunc(x)
+    },
+    ...x
+)
+
+export const cos = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) return new x.constructor(
+            Math.cos(x.a) * Math.cosh(x.b),
+            -Math.sin(x.a) * Math.sinh(x.b)
+        );
+        return Math.cos(x)
+    }
+    ,...x
+);
+
+export const sin = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex) return new x.constructor(
+            Math.sin(x.a) * Math.cosh(x.b),
+            Math.cos(x.a) * Math.sinh(x.b)
+        );
+        return Math.sin(x)
+    }
+    , ...x
+);
+
+export const tan = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const D = Math.cos(2*x.a) + Math.cosh(2*x.b);
+            return new x.constructor(
+                Math.sin(2*x.a) / D,
+                Math.sinh(2*x.b) / D
+            );
+        } 
+        return Math.tan(x) 
+    },
+    ...x
+);
+
+export const sec = (...x) => mapfun(
+    x => {
+        if(x.isComplex?.()) {
+
+        }
+        return 1 / Math.cos(x)
+    }
+    ,...x
+);
+
+export const acos = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const { a, b } = x;
+            const Rp = Math.hypot(a + 1, b);
+            const Rm = Math.hypot(a - 1, b);
+            globalThis.Rp = Rp
+            globalThis.Rm = Rm
+            return new x.constructor(
+                Math.acos((Rp - Rm) / 2),
+                -Math.acosh((Rp + Rm) / 2),
+            )
+        } 
+        return Math.acos(x) 
+    },
+    ...x
+);
+
+export const asin = (...x) => mapfun(
+    x => {
+        if(x?.isComplex){
+            const { a, b } = x;
+            const Rp = Math.hypot(a + 1, b);
+            const Rm = Math.hypot(a - 1, b);
+            return new x.constructor(
+                Math.asin((Rp - Rm) / 2), 
+                Math.acosh((Rp + Rm) / 2)
+            );
+        }
+        return Math.asin(x);
+    },
+    ...x
+);
+
+export const atan = (...x) => mapfun(
+    x => {
+        if(x?.isComplex){
+            const { a, b } = x;
+            return new x.constructor(
+                Math.atan((a*2/(1-a**2-b**2)))/2,
+                Math.log((a**2 + (1+b)**2)/(a**2 + (1-b)**2))/4
+            )
+        }
+        return Math.atan(x);
+    },
+    ...x
+);
+
+export const acot = (...x) => mapfun(
+    x => {
+        if(x?.isComplex){
+            const { a, b } = x;
+            return new x.constructor(
+                Math.atan(2*a/(a**2+(b-1)*(b+1)))/2,
+                Math.log((a**2 + (b-1)**2)/(a**2 + (b+1)**2))/4   
+            )
+        }
+        return Math.PI/2 - Math.atan(x);
+    },
+    ...x
+);
+
+
+export const cosh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex) return new x.constructor(
+            cosh(x.a)*cos(x.b),
+            sinh(x.a)*sin(x.b)
+        ); 
+        return cosh(x)
+    },
+    ...x
+)
+export const sinh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex) return new x.constructor(
+            sinh(x.a)*cos(x.b),
+            cosh(x.a)*sin(x.b)
+        ); 
+        return sinh(x)
+    },
+    ...x
+)
+export const tanh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const D=cosh(2*a)+cos(2*b);
+            return new x.constructor(
+                sinh(2*a)/D,
+                sin(2*b)/D
+            )
+        } 
+        return tanh(x)
+    },
+    ...x
+)
+
+export const coth = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            const {a, b} = x
+            const D = (Math.sinh(a)**2)*(Math.cos(b)**2) + (Math.cosh(a)**2)*(Math.sin(b)**2) 
+            return new x.constructor(
+                Math.cosh(a) * Math.sinh(a) / D,
+                - Math.sin(b) * Math.cos(b) / D
+            )
+        } 
+        return 1/Math.tanh(x)
+    },
+    ...x
+)
+
+export const acosh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            return ln(x.clone().add(sqrt(x.clone().mul(x.clone()).sub(1))))
+        } 
+        return Math.acosh(x)
+    },
+    ...x
+)
+
+export const asinh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+            return ln(x.clone().add(sqrt(x.clone().mul(x.clone()).add(1))))
+        } 
+        return Math.asinh(x)
+    },
+    ...x
+)
+
+export const atanh = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+
+        } 
+        return Math.atanh(x)
+    },
+    ...x
+)
+
+export const sig = (...x) => mapfun(
+    x =>{
+        if(x?.isComplex){
+
+        } 
+        return 1/(1+Math.e(-x))
+    },
+    ...x
+)

package/src/math/mapfun/index.js

@@ -0,0 +1,19 @@
+import { is_primitive } from "../../helpers/checkers/index.js";
+export const mapfun=(fun,...X)=>{
+    const Y=X.map(x=>{
+        if(is_primitive(x) || x?.__mapfun__) return fun(x)
+        if(x instanceof Array) return x.map(n=>mapfun(fun,n));
+        if(ArrayBuffer.isView(x)) return x.map(n=>fun(n));
+        if(x instanceof Set) return new Set(mapfun(fun,...[...x]));
+        if(x instanceof Map) return new Map([...x].map(n=>[n[0],mapfun(fun,n[1])]));
+        if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun(x.arr.flat(1)))
+        else if(x instanceof Object){
+            return Object.fromEntries(
+                Object.entries(x).map(
+                    n=>n=[n[0],mapfun(fun,n[1])]
+                )
+            )
+        }
+    });
+   return Y.length==1? Y[0]: Y; 
+}

package/src/math/utils/index.js

@@ -1,4 +1,4 @@
-import { mapfun } from "./mapfun.js";
+import { mapfun } from "../mapfun/index.js";
 import { 
     add,
     sub,

package/src/math/utils/mapfun.js

@@ -1,43 +1,43 @@
-import {ln,e,cos,sin,sqrt,cosh,sinh} from "../functions/index.js";
-import { Fixed } from "../functions/helper.js";
-// To generalise
 const mapfun=(fun,...X)=>{
     const Y=X.map(x=>{
-        if(x===null) return fun(null);
-        if(["number","string","boolean","bigint","undefined"].includes(typeof x)) return fun(x);
+        if(
+            x===null||
+            ["number","string","boolean","bigint","undefined"].includes(typeof x)||
+            x?.__mapfun__
+        ) return fun(x)
         if(x instanceof Array) return x.map(n=>mapfun(fun,n));
         if(ArrayBuffer.isView(x)) return x.map(n=>fun(n));
         if(x instanceof Set) return new Set(mapfun(fun,...[...x]));
         if(x instanceof Map) return new Map([...x].map(n=>[n[0],mapfun(fun,n[1])]));
         if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun(x.arr.flat(1)))
-        if(x.isComplex?.()){
-            const complex = (...args) => new x.constructor(...args) 
-            const [a,b,z,phi]=[x.a,x.b,x.z,x.phi];
-            switch(fun){
-                case Math.log: return complex(ln(z),phi); // Done
-                case Math.exp: return complex(e(a)*cos(b),e(a)*sin(b)); // Done
-                case Math.abs: return z; // Done
-                case Math.sqrt: return complex(sqrt(z)*cos(phi/2),sqrt(z)*sin(phi/2)); // Done
-                case Fixed.cos: return complex(cos(a)*cosh(b),-(sin(a)*sinh(b)));
-                case Fixed.sin: return complex(sin(a)*cosh(b),cos(a)*sinh(b));
-                case Fixed.tan:{
-                    const DEN = cos(2*a)+cosh(2*b);
-                    return complex(sin(2*a)/DEN,sinh(2*b)/DEN);
-                }
-                case Fixed.cosh:return complex(cosh(a)*cos(b),sinh(a)*sin(b));
-                case Fixed.sinh:return complex(sinh(a)*cos(b),cosh(a)*sin(b));
-                case Fixed.tanh:{
-                    const DEN=cosh(2*a)+cos(2*b);
-                    return complex(sinh(2*a)/DEN,sin(2*b)/DEN)
-                }
-                default : return fun(x)
-            }
-        }
+        // if(x.isComplex?.()){
+        //     const [a,b,z,phi]=[x.a,x.b,x.z,x.phi];
+        //     switch(fun){
+        //         // Moved to Fixed to avoid Circular Dep
+        //         // case Math.log: return new x.constructor(ln(z),phi); // Done
+        //         // case Math.exp: return new x.constructor(e(a)*cos(b),e(a)*sin(b)); // Done
+        //         // case Math.abs: return z; // Done
+        //         // case Math.sqrt: return new x.constructor(sqrt(z)*cos(phi/2),sqrt(z)*sin(phi/2)); // Done
+        //         // case Fixed.cos: return new x.constructor(cos(a)*cosh(b),-(sin(a)*sinh(b)));
+        //         // case Fixed.sin: return new x.constructor(sin(a)*cosh(b),cos(a)*sinh(b));
+        //         // case Fixed.tan:{
+        //         //     const DEN = cos(2*a)+cosh(2*b);
+        //         //     return new x.constructor(sin(2*a)/DEN,sinh(2*b)/DEN);
+        //         // }
+        //         // case Fixed.cosh:return new x.constructor(cosh(a)*cos(b),sinh(a)*sin(b));
+        //         // case Fixed.sinh:return new x.constructor(sinh(a)*cos(b),cosh(a)*sin(b));
+        //         // case Fixed.tanh:{
+        //         //     const DEN=cosh(2*a)+cos(2*b);
+        //         //     return new x.constructor(sinh(2*a)/DEN,sin(2*b)/DEN)
+        //         // }
+        //         default : return fun(x)
+        //     }
+        // }
         else if(x instanceof Object){
             return Object.fromEntries(Object.entries(x).map(n=>n=[n[0],mapfun(fun,n[1])]))
-            return fun(Object) || Object.fromEntries(Object.entries(x).map(n=>n=[n[0],mapfun(fun,n[1])]))
+            // return fun(Object) || Object.fromEntries(Object.entries(x).map(n=>n=[n[0],mapfun(fun,n[1])]))
         }
     });
-   return Y.length==1?Y[0]:Y; 
+   return Y.length==1? Y[0]: Y; 
 }
 export {mapfun}

package/src/ui/constructors/UIElement.js

@@ -1,5 +1,5 @@
 import { UIElementCore } from "./UIElementCore.js";
-import { register_to_class } from "../../__helpers__/register/register-to-class.js";
+import { register_to_class } from "../../helpers/register/register-to-class.js";
 import { 
   LifecycleMethods,
   AttrsMethods,
@@ -8,14 +8,14 @@ import {
   EventsMethodes,
   StyleMethods
 } from "../__methods__/index.js";
-import { 
-  // useCustomEvent,
-  // useSwipeEvent,
-  // watchIntersection, 
-  // watchSize,
-  // watchAttr,
-  // watchChildren
-} from "../../--reactivity-deprecated/events/custom-event.js"
+// import { 
+//   // useCustomEvent,
+//   // useSwipeEvent,
+//   // watchIntersection, 
+//   // watchSize,
+//   // watchAttr,
+//   // watchChildren
+// } from "../../--reactivity-deprecated/events/custom-event.js"
 class UIElement extends UIElementCore{
   constructor({element, name ='', type='html', render = __Ziko__.__Config__.default.render}={}){
     super()