ziko 0.50.2 → 0.51.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziko",
-  "version": "0.50.2",
+  "version": "0.51.1",
   "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__/checkers/index.js

@@ -1 +1,2 @@
 export const is_primitive = value => typeof value !== 'object' && typeof value !== 'function' || value === null;
+export const is_async = fn => fn && fn.constructor && fn.constructor.name === "AsyncFunction";

package/src/data/converter/csv.js

@@ -1,4 +1,4 @@
-import { Matrix } from "../../math/matrix/Matrix.js"
+import { Matrix } from "../../math/matrix/matrix.js"
 const csv2arr = (csv, delimiter = ",")=>csv.trim().trimEnd().split("\n").map(n=>n.split(delimiter));
 const csv2matrix = (csv, delimiter = ",")=>new Matrix(csv2arr(csv,delimiter));
 const csv2object = (csv, delimiter = ",") => {

package/src/events/binders/coordinates-based-event.js

@@ -0,0 +1,25 @@
+import { ZikoEvent } from "../ziko-event.js";
+
+export class CoordinatesBasedEvent extends ZikoEvent{
+    constructor(signature, target = null, Events = [], details_setter, customizer){
+        super(signature, target, Events, details_setter, customizer)
+        Object.assign(this.cache,{
+            useNormalisedCoordinates : false
+        })
+        this.isDown = false;
+        this.isMoving = false;
+        this.dx = 0;
+        this.dy = 0;
+        this.mx = 0;
+        this.my = 0;
+        this.ux = 0;
+        this.uy = 0;
+    }
+    get isDragging(){
+        return this.isDown && this.isMoving
+    }
+    useNormalisedCoordinates(enable = true){
+        this.cache.useNormalisedCoordinates = enable;
+        return this;
+    }
+}

package/src/events/binders/index.js

@@ -2,8 +2,13 @@ import { ZikoEvent } from "../ziko-event.js";
 import { EventsMap } from "../events-map/index.js";
 import {
     ptr_details_setter,
-    key_details_setter
+    key_details_setter,
+    mouse_details_setter,
+    touch_details_setter
 } from '../details-setter/index.js'
+import {
+    CoordinatesBasedEvent
+} from './coordinates-based-event.js'
 import { 
     register_click_away_event,
     register_view_event,
@@ -48,25 +53,25 @@ export const bind_key_event = (target, customizer) => new ZikoEvent(
     key_details_setter, 
     customizer
 );
-export const bind_mouse_event = (target, customizer) => new ZikoEvent(
+export const bind_mouse_event = (target, customizer) => new CoordinatesBasedEvent(
     'mouse',
     target,
     EventsMap.Mouse,
-    null,
+    mouse_details_setter,
     customizer
 );
-export const bind_pointer_event = (target, customizer) => new ZikoEvent(
+export const bind_pointer_event = (target, customizer) => new CoordinatesBasedEvent(
     'ptr',
     target,
     EventsMap.Ptr, 
     ptr_details_setter, 
     customizer
 );
-export const bind_touch_event = (target, customizer) => new ZikoEvent(
+export const bind_touch_event = (target, customizer) => new CoordinatesBasedEvent(
     'touch',
     target,
     EventsMap.Touch,
-    null,
+    touch_details_setter,
     customizer
 );
 export const bind_wheel_event = (target, customizer) => new ZikoEvent(

package/src/events/details-setter/index.js

@@ -1,2 +1,4 @@
 export * from './key.js'
-export * from './pointer.js'
+export * from './pointer.js'
+export * from './mouse.js'
+export * from './touch.js'

package/src/events/details-setter/mouse.js

@@ -0,0 +1,35 @@
+export function mouse_details_setter() {
+    const rect = this.targetElement.getBoundingClientRect();
+    const e = this.event;
+    let x = (e.clientX - rect.left) | 0;
+    let y = (e.clientY - rect.top) | 0;
+
+    if(this.cache.useNormalisedCoordinates){
+        const w = this.targetElement.clientWidth;
+        const h = this.targetElement.clientHeight;
+        x = +((x / w) * 2 - 1).toFixed(8);
+        y = +((y / h) * -2 + 1).toFixed(8);
+    }
+
+    switch (this.currentEvent) {
+
+        case "mousedown":
+            this.dx = x;
+            this.dy = y;
+            this.isDown = true;
+            break;
+
+        case "mousemove":
+            this.mx = x;
+            this.my = y;
+            this.isMoving = true;
+            break;
+
+        case "mouserup":
+            this.ux = x;
+            this.uy = y;
+            this.isDown = false;
+            this.isMoving = false;
+            break;
+    }
+}

package/src/events/details-setter/pointer.js

@@ -1,33 +1,35 @@
-export function ptr_details_setter(){
-    switch(this.currentEvent){
-        case "pointerdown" : {
-            this.dx = parseInt(this.event.offsetX);
-            this.dy = parseInt(this.event.offsetY);
-            this.isDown = true
-        }; break;
-        case "pointermove" : {
-            this.mx = parseInt(this.event.offsetX);
-            this.my = parseInt(this.event.offsetY);
-            this.isMoving = true
-        }; break;
-        case "pointerup" : {
-            this.ux = parseInt(this.event.offsetX);
-            this.uy = parseInt(this.event.offsetY);
+export function ptr_details_setter() {
+    const rect = this.targetElement.getBoundingClientRect();
+    const e = this.event;
+    let x = (e.clientX - rect.left) | 0;
+    let y = (e.clientY - rect.top) | 0;
+
+    if(this.cache.useNormalisedCoordinates){
+        const w = this.targetElement.clientWidth;
+        const h = this.targetElement.clientHeight;
+        x = +((x / w) * 2 - 1).toFixed(8);
+        y = +((y / h) * -2 + 1).toFixed(8);
+    }
+    switch (this.currentEvent) {
+
+        case "pointerdown":
+            this.dx = x;
+            this.dy = y;
+            this.isDown = true;
+            break;
+
+        case "pointermove":
+            this.mx = x;
+            this.my = y;
+            this.isMoving = true;
+            break;
+
+        case "pointerup":
+            this.ux = x;
+            this.uy = y;
             this.isDown = false;
-            console.log(this.target.width)
-            const delta_x=(this.ux-this.dx)/this.target.width;
-            const delta_y=(this.dy-this.uy)/this.target.height;
-            const HORIZONTAL_SWIPPE=(delta_x<0)?"left":(delta_x>0)?"right":"none";
-            const VERTICAL_SWIPPE=(delta_y<0)?"bottom":(delta_y>0)?"top":"none";
-            this.swippe={
-                h:HORIZONTAL_SWIPPE,
-                v:VERTICAL_SWIPPE,
-                delta_x,
-                delta_y
-            }
-        }; break;
+            this.isMoving = false;
+            break;
     }
-    // if(this.currentEvent==="click") this.dx = 0
-    // else this.dx = 1
-    // console.log(this.currentEvent)
-}
+}
+

package/src/events/details-setter/touch.js

@@ -0,0 +1,37 @@
+export function touch_details_setter() {
+    const e = this.event;
+    const touch = e.touches?.[0] || e.changedTouches?.[0];
+
+    if (!touch) return; // should never happen but safe
+
+    const rect = this.targetElement.getBoundingClientRect();
+    let x = touch.clientX - rect.left;
+    let y = touch.clientY - rect.top;
+
+    if(this.cache.useNormalisedCoordinates){
+        const w = this.targetElement.clientWidth;
+        const h = this.targetElement.clientHeight;
+        x = +((x / w) * 2 - 1).toFixed(8);
+        y = +((y / h) * -2 + 1).toFixed(8);
+    }
+
+    switch (this.currentEvent) {
+        case "touchstart":
+            this.dx = x;
+            this.dy = y;
+            this.isDown = true;
+            break;
+
+        case "touchmove":
+            this.mx = x;
+            this.my = y;
+            this.isMoving = true;
+            break;
+
+        case "touchend":
+            this.ux = x;
+            this.uy = y;
+            this.isDown = false;
+            break;
+    }
+}

package/src/math/complex/index.js

@@ -12,7 +12,6 @@ import{
     sqrt,
     ln
   }from "../functions/index.js"
-import { Matrix } from "../matrix/index.js";
 import {sum,prod,deg2rad} from "../utils/index.js";
 class Complex{
     constructor(a = 0, b = 0) {
@@ -183,10 +182,10 @@ class Complex{
 }
 const complex=(a,b)=>{
     if((a instanceof Array||ArrayBuffer.isView(a)) && (b instanceof Array||ArrayBuffer.isView(a)))return a.map((n,i)=>complex(a[i],b[i]));
-    if(a instanceof Matrix && b instanceof Matrix){
+    if(a.isMatrix?.() && b.isMatrix?.()){
         if((a.shape[0]!==b.shape[0])||(a.shape[1]!==b.shape[1]))return Error(0)
         const arr=a.arr.map((n,i)=>complex(a.arr[i],b.arr[i]))
-        return new Matrix(a.rows,a.cols,...arr)
+        return new a.constructor(a.rows,a.cols,...arr)
     }
     return new Complex(a,b)
 }

package/src/math/discret/Conversion/index.js

@@ -1,5 +1,5 @@
 import { Complex } from "../../complex/index.js";
-import { Matrix } from "../../matrix/Matrix.js";
+import { Matrix } from "../../matrix/matrix.js";
 const Base={
     _mode:Number,
     _map:function(func,number,toBase){

package/src/math/discret/Logic/index.js

@@ -1,5 +1,5 @@
 import { Complex } from "../../complex/index.js";
-import { Matrix } from "../../matrix/Matrix.js";
+import { Matrix } from "../../matrix/matrix.js";
 const Logic={
     _mode:Number,
     _map:function(func,a,b){

package/src/math/functions/index.js

@@ -1,5 +1,4 @@
 import { Fixed } from "./helper.js";
-import { Complex } from "../complex/index.js";
 import { mapfun } from "../utils/mapfun.js";
 import { 
     min,
@@ -11,12 +10,12 @@ const sqrt=(...x)=>mapfun(Math.sqrt,...x);
 const pow=(x,n)=>{
     if(typeof x === "number"){
         if(typeof n === "number")return Math.pow(x,n);
-        else if(n instanceof Complex)return Complex.fromExpo(x**n.a,n.b*ln(x))
+        else if(n?.isComplex?.())return n.constructor.fromExpo(x**n.a,n.b*ln(x))
         else return mapfun(a=>pow(x,a),...n);
     }
-    else if(x instanceof Complex){
-        if(typeof n === "number")return Complex.fromExpo(x.z**n,x.phi*n);
-        else if(n instanceof Complex)return Complex.fromExpo(
+    else if(x.isComplex?.()){
+        if(typeof n === "number")return x.constructor.fromExpo(x.z**n,x.phi*n);
+        else if(n.isComplex?.())return x.constructor.fromExpo(
             x.z**n.a*e(-x.phi*n.b),
             ln(x.z)*n.b+n.a*x.phi
         )
@@ -38,8 +37,8 @@ const sqrtn=(x,n)=>{
         if(typeof n === "number")return Math.pow(x,1/n);
         else return mapfun(a=>sqrtn(x,a),...n);
     }
-    else if(x instanceof Complex){
-        if(typeof n === "number")return Complex.fromExpo(sqrtn(x.z,n),x.phi/n);
+    else if(x.isComplex?.()){
+        if(typeof n === "number")return x.constructor.fromExpo(sqrtn(x.z,n),x.phi/n);
         else return mapfun(a=>sqrtn(x,a),...n);
     }
     else if(x instanceof Array){
@@ -81,8 +80,8 @@ const atan2=(x,y,rad=true)=>{
         if(typeof y === "number")return rad?Math.atan2(x,y):Math.atan2(x,y)*180/Math.PI;
         else return mapfun(a=>atan2(x,a,rad),...y);
     }
-    // else if(x instanceof Complex){
-    //     if(typeof n === "number")return Complex.fromExpo(x.z**n,x.phi*n);
+    // else if(x.isComplex?.()){
+    //     if(typeof n === "number")return x.constructor.fromExpo(x.z**n,x.phi*n);
     //     else return mapfun(a=>pow(x,a),...n);
     // }
     else if(x instanceof Array){

package/src/math/matrix/helpers/det.js

@@ -0,0 +1,36 @@
+import { add, sub, mul } from "../../utils/index.js";
+import { pow } from "../../functions/index.js";
+export function matrix_det(M) {
+    if (!M.isSquare) return new Error("is not square matrix");
+    if (M.rows == 1) return M.arr[0][0];
+    function determinat(M) {
+        if (M.length == 2) {
+            if (M.flat(1).some((n) => n?.isMatrix?.())) {
+                console.warn("Tensors are not completely supported yet ...");
+                return;
+            }
+            return sub(mul(M[0][0],M[1][1]),mul(M[0][1],M[1][0]))
+        }
+        var answer = 0;
+        for (var i = 0; i < M.length; i++) {
+            //console.log(M[0][i]);
+            /*answer = answer.add(
+                pow(-1, i)
+                    .mul(M[0][i])
+                    .mul(determinat(deleteRowAndColumn(M, i)))
+            );*/
+            //const to_be_added=add(mul(pow(-1, i),mul(M[0][i],determinat(deleteRowAndColumn(M, i)))));
+            const to_be_added=add(mul(pow(-1, i),mul(M[0][i],determinat(deleteRowAndColumn(M, i)))));
+            answer=add(answer,to_be_added)
+        }
+        return answer;
+    }
+    return determinat(M.arr);
+}
+function deleteRowAndColumn(M, index) {
+    var temp = [];
+    for (let i = 0; i < M.length; i++) temp.push(M[i].slice(0));
+    temp.splice(0, 1);
+    for (let i = 0; i < temp.length; i++) temp[i].splice(index, 1);
+    return temp;
+}

package/src/math/matrix/helpers/index.js

@@ -0,0 +1,3 @@
+export * from './inverse.js'
+export * from './det.js'
+export * from './stack.js'

package/src/math/matrix/helpers/inverse.js

@@ -0,0 +1,52 @@
+export function matrix_inverse(M) {
+    if(M.row !== M.cols) throw Error('is not a square matrix"')
+    if (M.det === 0) throw Error("determinant should not equal 0");
+    const { arr } = M
+    if (arr.length !== arr[0].length) return;
+    var i = 0, ii = 0, j = 0, dim = arr.length, e = 0;
+    var I = [], C = [];
+    for (i = 0; i < dim; i += 1) {
+        I[I.length] = [];
+        C[C.length] = [];
+        for (j = 0; j < dim; j += 1) {
+            if (i == j) I[i][j] = 1;
+            else I[i][j] = 0;
+            C[i][j] = arr[i][j];
+        }
+    }
+    for (i = 0; i < dim; i += 1) {
+        e = C[i][i];
+        if (e == 0) {
+            for (ii = i + 1; ii < dim; ii += 1) {
+                if (C[ii][i] != 0) {
+                    for (j = 0; j < dim; j++) {
+                        e = C[i][j];
+                        C[i][j] = C[ii][j];
+                        C[ii][j] = e;
+                        e = I[i][j];
+                        I[i][j] = I[ii][j];
+                        I[ii][j] = e;
+                    }
+                    break;
+                }
+            }
+            e = C[i][i];
+            if (e == 0) return;
+        }
+        for (j = 0; j < dim; j++) {
+            C[i][j] = C[i][j] / e;
+            I[i][j] = I[i][j] / e;
+        }
+        for (ii = 0; ii < dim; ii++) {
+            if (ii == i) {
+                continue;
+            }
+            e = C[ii][i];
+            for (j = 0; j < dim; j++) {
+                C[ii][j] -= e * C[i][j];
+                I[ii][j] -= e * I[i][j];
+            }
+        }
+    }
+    return new M.constructor(I);
+}

package/src/math/matrix/helpers/stack.js

@@ -0,0 +1,24 @@
+export function hstack(M1, M2){
+    M1 = M1.clone()
+    M2 = M2.clone()
+    if (M1.rows !== M2.rows) return;
+    let newArr = M1.arr;
+    for (let i = 0; i < M1.rows; i++) 
+        for (let j = M1.cols; j < M1.cols + M2.cols; j++) 
+            newArr[i][j] = M2.arr[i][j - M1.cols];
+    M1.cols += M2.cols;
+    return new M1.constructor(M1.rows, M1.cols, newArr.flat(1));
+}
+
+export function vstack(M1, M2){
+    M1 = M1.clone()
+    M2 = M2.clone()
+    if (M1.cols !== M2.cols) return;
+    let newArr = M1.arr;
+    for (let i = M1.rows; i < M1.rows + M2.rows; i++) {
+        newArr[i] = [];
+        for (let j = 0; j < M1.cols; j++) newArr[i][j] = M2.arr[i - M1.rows][j];
+    }
+    M1.rows += M2.rows;
+    return new M1.constructor(M1.rows, M1.cols, newArr.flat(1));
+}

package/src/math/matrix/index.js

@@ -1 +1 @@
-export * from "./Matrix.js"
+export * from "./matrix.js"