ziko 0.0.11 → 0.0.13

package/src/graphics/svg/Elements/Basic/link.js

@@ -0,0 +1,30 @@
+import ZikoSvgElement from "../ZikoSvgElement.js";
+class ZikoSvgLink extends ZikoSvgElement{
+    constructor(href,...svgElement){
+      super();
+      this.items=[];
+      this.element=document?.createElementNS(
+        "http://www.w3.org/2000/svg",
+        "a",
+      );
+      this.element.etAttribute("href",href)
+      this.add(...svgElement)
+    }
+    add(...svgElement){
+      for(let i=0;i<svgElement.length;i++){
+        this.element.ppendChild(svgElement[i].element);
+        this.items.push(svgElement[i])
+      }
+      if(svgElement.length===1)return svgElement[0]
+      return svgElement;
+    }
+    remove(...svgElement){
+      for(let i=0;i<svgElement.length;i++){
+        this.element.moveChild(svgElement[i].element);
+        this.items=this.items.filter(n=>n!=svgElement)
+      }
+      return this;     
+    }
+}
+const svgLink=(href,...svgElement)=>new ZikoSvgLink(href,...svgElement)
+export{ svgLink }

package/src/graphics/svg/Elements/Basic/path.js

@@ -0,0 +1,59 @@
+import ZikoSvgElement from "../ZikoSvgElement.js";
+class ZikoSvgPath extends ZikoSvgElement{
+    constructor(){
+    super()
+      this.element=document?.createElementNS(
+        "http://www.w3.org/2000/svg",
+        "path",
+      );
+      this.path="";
+      
+    }
+    setPath(){
+        this.element.etAttribute("d",this.path);
+        return this;
+    }
+    clear(){
+        this.path="";
+        this.setPath();
+        return this;
+    }
+    moveTo(x,y){
+        this.path+=`M${x} ${y} `;
+        this.setPath();
+        return this;
+    }
+    lineTo(x,y){
+        this.path+=`L${x} ${y} `;
+        this.setPath();
+        return this;
+    }
+    hr(x){
+        this.path+=`H${x} `;
+        this.setPath();
+        return this;
+    }
+    vr(y){
+        this.path+=`V${y} `;
+        this.setPath();
+        return this;
+    }
+    bezier(x1,y1,x2,y2,x,y){
+        this.path+=`C ${x1} ${y1},${x2} ${y2},${x} ${y} `;
+        this.setPath();
+        return this;      
+    }
+    quadratic(x1,y1,x,y){
+        this.path+=`Q ${x1} ${y1} ${x} ${y} `;
+        this.setPath();
+        return this;      
+    }
+    close(){
+        this.path+="Z";
+        this.setPath();
+        return this;
+    }
+}
+
+const svgPath=()=>new ZikoSvgPath();
+export{ svgPath }

package/src/graphics/svg/Elements/Basic/polygon.js

@@ -0,0 +1,32 @@
+import ZikoSvgElement from "../ZikoSvgElement.js";
+class ZikoSvgPolygon extends ZikoSvgElement{
+    constructor(X=[],Y=[]){
+      super()
+      this.X=X;
+      this.Y=Y
+      this.element=document?.createElementtNS(
+        "http://www.w3.org/2000/svg",
+        "polygon",
+      );
+      this.element?.setAttribute("points","");
+      this.addPoints(X,Y)
+    }
+    addPoint(x,y){
+      let p=this.element.parentElement.createSVGPoint();
+      p.x=x;
+      p.y=y;
+      this.element.points.appendItem(p);
+      return this;
+    }
+    addPoints(X,Y){
+      for(let i=0;i<X.length;i++){
+        let p=this.element.parentElement.createSVGPoint();
+        p.x=X[i];
+        p.y=Y[i];
+        this.element.oints.appendItem(p)
+      }
+      return this;
+    }
+  } 
+const svgPolygon=(X,Y)=>new ZikoSvgPolygon(X,Y);
+export{ svgPolygon }

package/src/graphics/svg/Elements/Basic/polyline.js

@@ -0,0 +1,4 @@
+import ZikoSvgElement from "../ZikoSvgElement.js";
+class ZikoSvgPolyLine extends ZikoSvgElement{}
+const svgPolyLine=(X,Y)=>new ZikoSvgPolyLine(X,Y);
+export { svgPolyLine }

package/src/graphics/svg/Elements/Basic/rect.js

@@ -0,0 +1,43 @@
+
+import ZikoSvgELement from "../ZikoSvgElement.js";
+class ZikoSvgRectangle extends ZikoSvgELement{
+    constructor(x,y,w,h,center=true){
+      super()
+      this.element=document?.createElementNS(
+        "http://www.w3.org/2000/svg",
+        "rect",
+      );
+      this.setX(x).setY(y).width(w).height(h);
+      this.rx=this.x+this.w/2;
+      this.ty=this.y+this.h/2;
+    }
+    setX(x){
+       this.element.x.baseVal.value=x;
+       this.x=x;
+       return this;
+    }
+    setY(y){
+       this.element.y.baseVal.value=y;
+       this.y=y;
+       return this;
+    }
+    r(rx,ry){
+      this.rx=rx;
+      this.ry=ry;
+      this.setX(this.rx-this.w/2);
+      this.setY(this.ry-this.h/2);
+      return this;
+    } 
+    width(w){
+       this.element.width.baseVal.value=w;
+       this.w=w;
+       return this;
+    } 
+    height(h){
+       this.element.height.baseVal.value=h;
+       this.h=h;
+       return this;
+    } 
+  } 
+  const svgRect=(x,y,w,h,center)=>new ZikoSvgRectangle(x,y,w,h,center);
+  export{ svgRect }

package/src/graphics/svg/Elements/Basic/text.js

@@ -0,0 +1,26 @@
+import ZikoSvgElement from "../ZikoSvgElement.js";
+class ZikoSvgText extends ZikoSvgElement{
+    constructor(text,x,y){
+      super()
+      this.element=document?.createElementNS(
+        "http://www.w3.org/2000/svg",
+        "text",
+      );
+      this.setText(text)
+      this.x(x).y(y);
+    }
+    x(x){
+       this.element?.setAttribute("x",x);
+       return this;
+    }
+    y(y){
+       this.element?.setAttribute("y",y);
+       return this;
+    }
+    setText(text=""){
+      this.element.textContent=text;
+      return this;
+    }
+  } 
+const svgText=(text,x,y)=>new ZikoSvgText(text,x,y);
+export{ svgText }

package/src/graphics/svg/Elements/Derived/grid.js

@@ -0,0 +1,9 @@
+import { svgPath } from "../Basic/path"
+const svgGrid=(w,h,r=10,c=10)=>{
+    let path=svgPath().fill("none").stroke("coral").strokeWidth(0.6)
+    console.log({x:w/r,y:h/c})
+    for(let i=0;i<w;i++) path.moveTo(0,i*w/r).hr(w)
+    for(let j=0;j<h;j++) path.moveTo(j*h/c,0).vr(h)
+    return path
+}
+export{ svgGrid };

package/src/graphics/svg/Elements/ZikoSvgElement.js

@@ -0,0 +1,46 @@
+class ZikoSvgElement {
+  constructor(type) {
+    this.cache = {
+      type
+    };
+  }
+  pos(x,y){
+    return this.posX(x).posY(y);
+  }
+  posX(x){
+    if(["circle","ellipse"].includes(this.cache.type))this.element.cx.baseVal.value=x;
+    else this.element.x.baseVal.value=x;
+    return this;
+  }
+  posY(y){
+    if(["circle","ellipse"].includes(this.cache.type))this.element.cy.baseVal.value=y;
+    else this.element.y.baseVal.value=y;
+    return this;
+  }
+  translate(x,y){
+    return this;
+  }
+  color({ stroke, fill }) {
+    this.element?.setAttribute("stroke", stroke);
+    this.element?.setAttribute("fill", fill);
+    return this;
+  }
+  fill(color = "none") {
+    this.element?.setAttribute("fill", color);
+    return this;
+  }
+  stroke(color = "none", width) {
+    this.element?.setAttribute("stroke", color);
+    width && this.strokeWidth(width);
+    return this;
+  }
+  strokeWidth(width = 1) {
+    this.element?.setAttribute("stroke-width", width);
+    return this;
+  }
+  opacity(value = 1) {
+    this.element?.setAttribute("opacity", value);
+    return this;
+  }
+}
+export default ZikoSvgElement;

package/src/graphics/svg/Elements/index.js

@@ -0,0 +1,14 @@
+export { svgRect } from "./Basic/rect.js";
+export { svgCircle } from "./Basic/circle.js";
+export { svgEllipse } from "./Basic/ellipse.js";
+export { svgLine } from "./Basic/line.js";
+export { svgPolyLine } from "./Basic/polyline.js";
+export { svgPath } from "./Basic/path.js";
+export { svgPolygon } from "./Basic/polygon.js";
+export { svgText } from "./Basic/text.js";
+export { svgImage } from "./Basic/image.js";
+export { svgObject } from "./Basic/foreignObject.js";
+export { svgGroupe } from "./Basic/groupe.js";
+export { svgLink } from "./Basic/link.js";
+
+export { svgGrid } from "./Derived/grid.js";

package/src/graphics/svg/index.js

@@ -0,0 +1,2 @@
+export * from "./svg.js"
+export * from "./Elements/index.js"

package/src/graphics/svg/svg.js

@@ -0,0 +1,115 @@
+import ZikoUIElement from "../../user-interface/elements/primitives/ZikoUIElement.js";
+// import svgRect from "./Elements/rect.js";
+// import svgCircle from "./Elements/circle.js";
+// import svgEllipse from "./Elements/ellipse.js";
+// import svgLine from "./Elements/line.js";
+// //import svgPath from "./Elements/path.js";
+// import svgPolygon from "./Elements/polygon.js";
+// import svgImage from "./Elements/image.js";
+// import svgText from "./Elements/text.js";
+// import svgGroupe from "./Elements/groupe.js";
+// import svgLink from "./Elements/link.js";
+// //import svgObject from "./Elements/foreignObject.js";
+// //import svgGrid from "./Elements/grid.js";
+
+  class ZikoUISvg extends ZikoUIElement {
+    constructor(w=360,h=300) {
+      super("svg","svg");
+      //this.cache={};
+      this.setAttr("width",w);
+      this.setAttr("height",h);
+      this.style({border:"1px black solid"});
+      //this.view(-w/2,-h/2,w/2,h/2)
+      this.view(-10,-10,10,10);
+    }
+    view(x1,y1,x2,y2){
+      let width=Math.abs(x2-x1);
+      let height=Math.abs(y2-y1);
+      this.setAttr("viewBox",[x1,y1,width,height].join(" "));
+      this.st.scaleY(-1);
+      return this;
+    }
+    add(...svgElement){
+      for(let i=0;i<svgElement.length;i++){
+        this.element?.appendChildddddddd(svgElement[i].element);
+        this.items.push(svgElement[i])
+      }
+      this.maintain()
+      return this;
+    }
+    remove(...svgElement){
+      for(let i=0;i<svgElement.length;i++){
+        this.element?.removeChild(svgElement[i].element);
+        this.items=this.items.filter(n=>!svgElement)
+      }
+      this.maintain();
+      return this;     
+    }
+    // text(text,x,y){
+    //   let item=svgText(text,x,y);
+    //   this.element?.appendChildd(item.element);
+    //   item.x(x-item.element.getComputedTextLength()/2);
+    //   return item;
+    // }
+    // rect(x,y,w,h){
+    //   let item=svgRect(x,y,w,h);
+    //   this.add(item);
+    //   return item;
+    // }
+    // line(x1,y1,x2,y2){
+    //   let item=svgLine(x1,y1,x2,y2);
+    //   this.element?.appendChildd(item.element);
+    //   return item;
+    // }
+    // circle(cx,cy,r){
+    //   let item=svgCircle(cx,cy,r);
+    //   this.element?.appendChildd(item.element);
+    //   return item;
+    // }
+    // ellipse(cx,cy,rx,ry){
+    //   let item=svgEllipse(cx,cy,rx,ry);
+    //   this.element?.appendChildd(item.element);
+    //   return item;
+    // }
+    // polygon(X,Y){
+    //   let item=svgPolygon(X,Y);
+    //   this.element?.appendChildd(item.element);
+    //   item.addPoints(X,Y)
+    //   return item;
+    // }
+    // image(src,w,h,x,y){
+    //   let item=svgImage(src,w,h,x,y);
+    //   this.element?.appendddChild(item.element);
+    //   return item;
+    // }
+    mask(){
+  
+    }
+    toString(){
+      return  (new XMLSerializer()).serializeToString(this.element);
+    }
+    btoa(){
+      return btoa(this.toString())
+    }
+    toImg(){
+      return 'data:image/svg+xml;base64,'+this.btoa()
+    }
+    toImg2(){
+      return "data:image/svg+xml;charset=utf8,"+this.toString().replaceAll("<","%3C").replaceAll(">","%3E").replaceAll("#","%23").replaceAll('"',"'");
+    }
+  }
+
+  const Svg =(w,h)=>new ZikoUISvg(w,h);
+  export{
+    Svg,
+    ZikoUISvg,
+    // svgLink,
+    // svgCircle,
+    // svgEllipse,
+    // svgImage,
+    // svgLine,
+    // svgPolygon,
+    // svgRect,
+    // svgText,
+    // svgGroupe
+}

package/src/index.js

@@ -0,0 +1,88 @@
+import Math from "./math/index.js";
+import UI from "./user-interface/index.js";
+import Time from "./time/index.js";
+import Data from "./data/index.js";
+import Reactivity from "./reactivity/index.js";
+import Graphics from "./graphics/index.js";
+import {SPA} from "./app/router/index.js";
+import { 
+    __UI__,
+    __Config__
+ } from "./app/globals/index.js";
+import ZikoUIElement from "./user-interface/elements/primitives/ZikoUIElement.js";
+import { 
+    App,
+ } from "./app";
+const Ziko={
+    App,
+    Math,
+    UI,
+    Time,
+    Graphics,
+    Reactivity,
+    Data,
+    SPA,
+}
+
+// if ( globalThis.__Ziko__ ) {
+//     console.warn( 'WARNING: Multiple instances of Ziko.js being imported.' );
+// 	} else {
+// 		globalThis.__Ziko__={
+//             ...Ziko,
+//             __UI__,
+//             __Config__,
+//             ExtractAll,
+//             RemoveAll
+//         };
+// 	}
+globalThis.__Ziko__={
+    ...Ziko,
+    __UI__,
+    __Config__,
+    ExtractAll,
+    RemoveAll
+};
+if(globalThis?.document){
+    document?.addEventListener("DOMContentLoaded", __Ziko__.__Config__.init());
+}
+function ExtractAll(){
+    UI.ExtractAll();
+    Math.ExtractAll();
+    Time.ExtractAll();
+    Reactivity.ExtractAll();
+    Graphics.ExtractAll();
+    Data.ExtractAll()
+    return this;
+}
+function RemoveAll(){
+    UI.RemoveAll();
+    Math.RemoveAll();
+    Time.RemoveAll();
+    Reactivity.RemoveAll();
+    Graphics.RemoveAll();
+    Data.RemoveAll()
+}
+export * from "./math/index.js";
+export * from "./user-interface/index.js";
+export * from "./graphics/index.js";
+export * from "./time/index.js";
+export * from "./data/index.js";
+export * from "./app";
+export * from "./reactivity/index.js"
+export {
+    App,
+    Math,
+    UI,
+    Time,
+    Graphics,
+    Reactivity,
+    Data,
+    ZikoUIElement,
+    SPA,
+    ExtractAll,
+    RemoveAll
+};
+export default Ziko;
+
+
+

package/src/math/absract.js

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

package/src/math/calculus/index.js

@@ -0,0 +1 @@
+export * from "./special-functions/index.js"

package/src/math/calculus/special-functions/bessel.js

@@ -0,0 +1,31 @@
+import { mapfun } from "../../utils/index.js";
+import { fact } from "../../functions/index.js";
+const _bessel=(n, x)=>{
+    const maxTerms = 100;
+    let result = 0;
+    for (let k = 0; k < maxTerms; k++) {
+        const numerator = Math.pow(-1, k) * Math.pow(x / 2, n + 2 * k);
+        const denominator = fact(k) * fact(n + k);
+        result += numerator / denominator;
+    }
+    return result;
+}
+const bessel=(n,x)=>{
+    if(typeof n === "number"){
+        if(typeof n === "number")return _bessel(n,x);
+        else console.warn("Not supported yet")
+    }
+    else if(n instanceof Array){
+        if(typeof x === "number") return mapfun(a=>_bessel(a,x),...n);
+        else if(x instanceof Array){
+            const Y=[];
+            for(let i=0;i<n.length;i++){
+                Y.push(mapfun(a=>_bessel(n[i],a),...x))
+            }
+            return Y;
+        }
+    }
+}
+export{
+    bessel
+}

package/src/math/calculus/special-functions/beta.js

@@ -0,0 +1,38 @@
+import { mapfun } from "../../utils/index.js";
+const _beta=(x, y)=>{
+    const lowerLimit = 0;
+    const upperLimit = 1;
+    const intervals = 1000;
+    let result = 0;
+
+    const f = (t) => Math.pow(t, x - 1) * Math.pow(1 - t, y - 1);
+    const h = (upperLimit - lowerLimit) / intervals;
+
+    result += 0.5 * (f(lowerLimit) + f(upperLimit));
+
+    for (let i = 1; i < intervals; i++) {
+        const xi = lowerLimit + i * h;
+        result += f(xi);
+    }
+
+    return result * h;
+}
+const beta=(x,y)=>{
+    if(typeof x === "number"){
+        if(typeof x === "number")return _beta(x,y);
+        else console.warn("Not supported yet")
+    }
+    else if(x instanceof Array){
+        if(typeof y === "number") return mapfun(a=>_beta(a,y),...x);
+        else if(y instanceof Array){
+            const Z=[];
+            for(let i=0;i<x.length;i++){
+                Z.push(mapfun(a=>_beta(x[i],a),...y))
+            }
+            return Z;
+        }
+    }
+}
+export{
+    beta
+}

package/src/math/calculus/special-functions/gamma.js

@@ -0,0 +1,30 @@
+import { mapfun } from "../../utils/mapfun.js";
+const _gamma=x=>{
+    // Coefficients for the Lanczos approximation
+    const g = 7;
+    const p = [
+        0.99999999999980993,
+        676.5203681218851,
+        -1259.1392167224028,
+        771.32342877765313,
+        -176.61502916214059,
+        12.507343278686905,
+        -0.13857109526572012,
+        9.9843695780195716e-6,
+        1.5056327351493116e-7
+    ];
+    if (x < 0.5) {
+        return +(Math.PI / (Math.sin(Math.PI * x) * _gamma(1 - x))).toFixed(10);
+    }
+    x -= 1;
+    let a = p[0];
+    for (let i = 1; i < g + 2; i++) {
+        a += p[i] / (x + i);
+    }
+    const t = x + g + 0.5;
+    return +(Math.sqrt(2 * Math.PI) * Math.pow(t, (x + 0.5)) * Math.exp(-t) * a).toFixed(10);
+}
+const gamma=(...x)=>mapfun(_gamma,...x);
+export{
+    gamma
+}

package/src/math/calculus/special-functions/index.js

@@ -0,0 +1,4 @@
+export * from "./gamma.js";
+export * from "./bessel.js";
+export * from "./beta.js";
+