ziko 0.51.1 → 0.52.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.51.1",
+  "version": "0.52.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
     }

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,176 @@
+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 sqrt = (...x) => mapfun(
+    x=>{
+        if(x.isComplex?.()){
+            const {z, phi} = x
+            return new x.constructor(
+                Math.sqrt(z) * Math.cos(phi/2),
+                Math.sqrt(z) * Math.sin(phi/2)
+            );
+        } 
+        return Math.sqrt(x);
+    },
+    ...x
+)
+
+export const e = (...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 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 DEN = Math.cos(2*x.a) + Math.cosh(2*x.b);
+            return new x.constructor(
+                Math.sin(2*x.a) / DEN,
+                Math.sinh(2*x.b) / DEN
+            );
+        } 
+        return Math.tan(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
+            console.log({a, b, Rp, 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 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 DEN=cosh(2*a)+cos(2*b);
+            return new x.constructor(
+                sinh(2*a)/DEN,
+                sin(2*b)/DEN
+            )
+        } 
+        return tanh(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()

package/src/ui/constructors/UIElementCore.js

@@ -1,7 +1,7 @@
 import {UINode} from "./UINode.js";
-// import {__init__global__} from '../../__ziko__/index.js';
+import {__init__global__} from '../../__ziko__/index.js';
 import { UIStore } from "../../__ziko__/__ui__.js";
-// __init__global__()
+__init__global__()
 class UIElementCore extends UINode{
   constructor(){
     super()

package/types/math/adapted/index.d.ts

@@ -0,0 +1,4 @@
+import type { Complex } from '../complex'
+export declare function adapted_cos(x: Complex): Complex;
+export declare function adapted_cos(x: number): number;
+

package/types/math/complex/index.d.ts

@@ -16,7 +16,7 @@ export declare class Complex {
 
     isComplex(): true;
     toString(): string;
-
+    readonly __mapfun__ : boolean
     readonly clone: Complex;
     readonly z: number;
     readonly phi: number;

package/types/math/mapfun/index.d.ts

@@ -0,0 +1,87 @@
+import { Complex } from "../../../src/math/index.js";
+import { Matrix } from "../../../src/math/matrix/index.js";
+
+/**
+ * Objects that behave like primitives for mapfun,
+ * meaning fun(x) is applied directly without recursion.
+ */
+export interface MapfunPrimitiveLike {
+    __mapfun__?: boolean;
+}
+
+export type PrimitiveLike =
+    | number
+    | boolean
+    | string
+    | bigint
+    | undefined
+    | null
+    | { readonly __mapfun__: boolean };
+
+export type Mappable =
+    | number
+    | string
+    | boolean
+    | bigint
+    | undefined
+    | null
+    | Matrix
+    | MapfunPrimitiveLike
+    | any[]
+    | Set<any>
+    | Map<any, any>
+    | object;
+
+/**
+ * mapfun transform rules
+ */
+export type MapfunResult<F extends (x: any) => any, T> =
+    // Objects with __mapfun__ → treat as primitive (call fun(x))
+    // T extends MapfunPrimitiveLike
+    //     ? ReturnType<F> :
+
+    // Matrix → always return Matrix (your JS logic rebuilds a new Matrix)
+    
+    T extends PrimitiveLike 
+        ? ReturnType<F> :
+    // T extends Complex
+    //     ? T :
+    T extends Matrix
+        ? T :
+
+    // Array → deep-map
+    T extends Array<infer U>
+        ? Array<MapfunResult<F, U>> :
+
+    // Set → deep-map
+    T extends Set<infer U>
+        ? Set<MapfunResult<F, U>> :
+
+    // Map → deep-map values
+    T extends Map<infer K, infer V>
+        ? Map<K, MapfunResult<F, V>> :
+
+    // Other objects → recursively map fields
+    T extends object
+        ? { [K in keyof T]: MapfunResult<F, T[K]> } :
+
+    // Primitive
+    ReturnType<F>;
+
+/**
+ * If only one argument → return mapped value
+ * If multiple → return tuple of mapped values
+ */
+type UnwrapSingle<T extends unknown[]> =
+    T extends [infer U] ? U : { [K in keyof T]: T[K] };
+
+/**
+ * mapfun main declaration
+ */
+export declare function mapfun<
+    F extends (x: any) => any,
+    A extends Mappable[]
+>(
+    fun: F,
+    ...values: A
+): UnwrapSingle<{ [K in keyof A]: MapfunResult<F, A[K]> }>;