ziko 0.0.11 → 0.0.13

package/src/data/converter/markdown.js

@@ -0,0 +1,95 @@
+const parseInlineElements = text => {
+    return text
+        .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>') 
+        .replace(/\*(.*?)\*/g, '<em>$1</em>')              
+        .replace(/\[(.*?)\]\((.*?)\)/g, '<a href="$2">$1</a>')  
+        .replace(/!\[(.*?)\]\((.*?)\)/g, '<img src="$2" alt="$1">') 
+        .replace(/`([^`]+)`/g, '<code>$1</code>'); // Inline Code
+};
+
+const parseTable = line => {
+    const cells = line.split('|').map(cell => cell.trim()).filter(cell => cell !== '');
+    const tableRow = cells.map(cell => `<td>${parseInlineElements(cell)}</td>`).join('');
+    return `<tr>${tableRow}</tr>\n`;
+};
+
+const parseCodeBlock = (lines, language) => {
+    const codeContent = lines.join('\n'); // No need to exclude the triple backticks
+    const highlightedCode = language ? `<pre><code data-language="${language}">${codeContent}</code></pre>` : `<pre><code>${codeContent}</code></pre>`;
+    return `${highlightedCode}\n`;
+};
+
+const parseList = line => {
+    const DIGIT_FOLLOWED_BY_A_DOT_AND_SPACE = /^\d+\.\s/; 
+    const match = line.match(DIGIT_FOLLOWED_BY_A_DOT_AND_SPACE);
+    if (match) {
+        let start = +match[1];
+        return `<ol${start===1?"":` start="${start}"`}>${parseInlineElements(line.slice(match[0].length))}</ol>\n`;
+    }  
+    return `<ul>${parseInlineElements(line)}</ul>\n`;
+};
+
+const parseHorizontalRule = () => {
+    return '<hr>\n';
+};
+
+const markdown2html = markdownText => {
+    const lines = markdownText.split('\n');
+    let htmlOutput = '';
+    let inTable = false;
+    let inCodeBlock = false;
+    let codeBlockLines = [];
+    let codeBlockLanguage = '';
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        // Table
+        if (line.startsWith('|')) {
+            if (!inTable) {
+                inTable = true;
+                htmlOutput += '<table>\n';
+            }
+            htmlOutput += parseTable(line);
+            continue;
+        } else if (inTable) {
+            inTable = false;
+            htmlOutput += '</table>\n';
+        }
+        // Code block
+        if (line.startsWith('```')) {
+            if (!inCodeBlock) {
+                inCodeBlock = true;
+                codeBlockLines = [];
+                codeBlockLanguage = line.slice(3).trim();
+            } else {
+                inCodeBlock = false;
+                htmlOutput += parseCodeBlock(codeBlockLines, codeBlockLanguage);
+            }
+            continue;
+        } else if (inCodeBlock) {
+            codeBlockLines.push(line);
+            continue;
+        }
+        // Headings
+        if (line.startsWith('# ')) {
+            const headingLevel = line.indexOf(' ');
+            const headingText = line.slice(headingLevel + 1);
+            htmlOutput += `<h${headingLevel}>${parseInlineElements(headingText)}</h${headingLevel}>\n`;
+            continue;
+        }
+        // Lists
+        if (line.startsWith('- ') || line.startsWith('* ') || line.match(/^\d+\.\s/)) {
+            htmlOutput += parseList(line);
+            continue;
+        }
+        // Horizontal Rule
+        if (line.trim() === '---') {
+            htmlOutput += parseHorizontalRule();
+            continue;
+        }
+        // Other paragraphs
+        htmlOutput += `<p>${parseInlineElements(line)}</p>\n`;
+    }
+    return htmlOutput;
+};
+
+export { markdown2html };

package/src/data/converter/object.js

@@ -0,0 +1,70 @@
+import { arr2str } from "../index.js";
+import { Complex, mapfun, Matrix } from "../../math/index.js";
+
+// const obj2str=(object)=>{
+//     const recursiveToString = (obj) => {
+//       if (Array.isArray(obj)) return arr2str(obj);
+//       if (typeof obj === 'object' && obj !== null) {
+//         return `{ ${Object.entries(obj)
+//           .map(([key, value]) => `${key}:${recursiveToString(value)}`)
+//           .join(" , ")} }`;
+//       }
+//       return String(obj); 
+//     };
+//     return recursiveToString(object);
+//   };
+//   const obj2str = (object) => {
+//     const recursiveToString = (obj, indentLevel = 0) => {
+//       const indent = '  '.repeat(indentLevel);
+//       const nextIndent = '  '.repeat(indentLevel + 1);
+//       if(Array.isArray(obj)) return arr2str(obj, indentLevel);
+//       if(obj instanceof Complex || obj instanceof Matrix) return obj.toString();
+//       if (typeof obj === 'object' && obj !== null) {
+//         const entries = Object.entries(obj)
+//           .map(([key, value]) => `${nextIndent}${key}: ${recursiveToString(value, indentLevel + 1)}`)
+//           .join(",\n");
+  
+//         return `{\n${entries}\n${indent}}`;
+//       }
+  
+//       return String(obj);
+//     };
+  
+//     return recursiveToString(object);
+//   };
+// const obj2str = (object, useIndentation = true, indentLevel = 0) => {
+//     const recursiveToString = (obj, level = 0) => {
+//       const indent = useIndentation ? '  '.repeat(level) : '';
+//       const nextIndent = useIndentation ? '  '.repeat(level + 1) : '';
+//     if (Array.isArray(obj)) return arr2str(obj, false, level);
+//     if(obj instanceof Complex || obj instanceof Matrix) return obj.toString();
+//     if (typeof obj === 'object' && obj !== null) {
+//         const entries = Object.entries(obj)
+//           .map(([key, value]) => useIndentation 
+//             ? `${nextIndent}${key}: ${recursiveToString(value, level + 1)}` 
+//             : `${key}: ${recursiveToString(value, level + 1)}`
+//           ).join(useIndentation ? ",\n" : ", ");
+  
+//         return useIndentation 
+//           ? `{\n${entries}\n${indent}}` 
+//           : `{${entries}}`;
+//       }
+  
+//       return String(obj);
+//     };
+  
+//     return recursiveToString(object, indentLevel);
+//   };
+
+const obj2str=(obj)=>JSON.stringify(
+  mapfun(n=>{
+    if(["number","string","boolean","bigint"].includes(typeof n)) return String(n);
+    if(n instanceof Complex || n instanceof Matrix) return n.toString();
+    if(n instanceof Array) return arr2str(n)
+  },
+  obj), null, "  ")
+  .replace(/"([^"]+)":/g, '$1:') // Remove Quotes from Keys 
+  .replace(/: "([^"]+)"/g, ': $1'); // Remove Quotes from str values
+export{
+    obj2str
+}

package/src/data/converter/svg.js

@@ -0,0 +1,11 @@
+import { image } from "../../user-interface/elements/primitives/media/Image/image.js"
+const svg2str=svg=>(new XMLSerializer()).serializeToString(svg);
+const svg2ascii=svg=>btoa(svg2str(svg));
+const svg2imgUrl=svg=>'data:image/svg+xml;base64,'+svg2ascii(svg);
+const svg2img=(svg,render=true)=>image(svg2imgUrl(svg)).render(render);
+export{
+    svg2str,
+    svg2ascii,
+    svg2imgUrl,
+    svg2img
+}

package/src/data/index.js

@@ -0,0 +1,74 @@
+import { 
+    obj2str,
+    arr2str,
+    markdown2html,
+    adoc2html,
+    csv2arr,
+    csv2matrix,
+    csv2object,
+    csv2json,
+    csv2sql,
+    json2arr,
+    json2csv,
+    json2csvFile,
+    json2yml,
+    json2ymlFile,
+    json2xml,
+    json2xmlFile,
+    svg2str,
+    svg2ascii,
+    svg2imgUrl,
+    svg2img,
+ } from "./converter/index.js";
+import parseXML from "./parser/xml.js";
+import { preload } from "./api/preload.js";
+import {str,Str} from "./string/index.js"
+const Data={
+    str,
+    Str,
+    parseXML,
+    preload,
+    obj2str,
+    arr2str,
+    markdown2html,
+    adoc2html,
+    csv2arr,
+    csv2matrix,
+    csv2object,
+    csv2json,
+    csv2sql,
+    json2arr,
+    json2csv,
+    json2csvFile,
+    json2yml,
+    json2ymlFile,
+    json2xml,
+    json2xmlFile,
+    svg2str,
+    svg2ascii,
+    svg2imgUrl,
+    svg2img,
+    ExtractAll: function () {
+        const keys = Object.keys(this);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (key !== 'ExtractAll' && key !== 'RemoveAll') {
+                globalThis[key] = this[key];
+            }
+        }
+        return this;
+    },
+    RemoveAll: function () {
+        const keys = Object.keys(this);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (key !== 'RemoveAll') {
+                delete globalThis[key];
+            }
+        }
+        return this;
+    }
+}
+export * from "./converter/index.js";
+export * from "./string/index.js"
+export default Data

package/src/data/parser/xml.js

@@ -0,0 +1,47 @@
+function parseXML(xmlString) {
+    const parser = new DOMParser();
+    const xmlDoc = parser.parseFromString(xmlString, 'text/xml');
+    const rootNode = xmlDoc.documentElement;
+    const result = parseNode(rootNode);
+    return result;
+  }
+  
+  function parseNode(node) {
+    const obj = {
+      type: node.nodeName,
+      attributes: {},
+      children: []
+    };
+    for (let i = 0; i < node.attributes.length; i++) {
+      const attr = node.attributes[i];
+      obj.attributes[attr.name] = attr.value;
+    }
+    for (let i = 0; i < node.childNodes.length; i++) {
+      const child = node.childNodes[i];
+      if (child.nodeType === Node.ELEMENT_NODE) {
+        obj.children.push(parseNode(child));
+      } else if (child.nodeType === Node.TEXT_NODE) {
+        obj.text = child.textContent.trim();
+      }
+    }
+    return obj;
+  }
+  export default parseXML;
+
+  // function htmlParser(element) {
+  //   const obj = {
+  //     type: element.tagName,
+  //     attributes: {},
+  //     children: [],
+  //   };
+  //   for (let i = 0; i < element.attributes.length; i++) {
+  //     const attr = element.attributes[i];
+  //     obj.attributes[attr.name] = attr.value;
+  //   }
+  //   for (let i = 0; i < element.children.length; i++) {
+  //     const child = element.children[i];
+  //     obj.children.push(htmlParser(child));
+  //   }
+  //   return obj;
+  // }
+ 

package/src/data/string/index.js

@@ -0,0 +1 @@
+export * from "./string.js";

package/src/data/string/patterns.js

@@ -0,0 +1,12 @@
+const Patterns={
+    isDigit: /^\d+$/,
+    isEmail: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+    isURL: /^(https?:\/\/)?([\w\-]+\.)+[\w\-]+(\/[\w\-./?%&=]*)?$/,
+    isHexColor: /^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/,
+    isIPv4: /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,
+    isMACAddress: /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/,
+    isDate: /^\d{4}-\d{2}-\d{2}$/,
+}
+export{
+    Patterns
+}

package/src/data/string/string.js

@@ -0,0 +1,170 @@
+import { Patterns } from "./patterns.js";
+class Str{
+    constructor(string){
+        this.string=string;
+    }
+    isDigit() {
+        return Patterns.isDigit.test(this.string);
+    }
+    static isDigit(string){
+        return new Str(string).isDigit();
+    }
+    isNumber() {
+        return !isNaN(this.string);
+    }
+    static isNumber(string){
+        return new Str(string).isNumber();
+    }
+    isUrl(){
+        return Patterns.isURL.test(this.string);
+    }
+    static isUrl(string){
+        return new Str(string).isUrl();
+    }
+    isHexColor(){
+        return Patterns.isHexColor.test(this.string);
+    }
+    static isHexColor(string){
+        return new Str(string).isHexColor();
+    }
+    isIPv4(){
+        return Patterns.isIPv4.test(this.string);
+    }
+    static isIPv4(string){
+        return new Str(string).isIPv4();
+    }
+    isDate(){
+        return Patterns.isDate.test(this.string);
+    }
+    static isDate(string){
+        return new Str(string).isDate();
+    }
+    isMACAddress(){
+        return Patterns.isMACAddress.test(this.string);
+    }
+    static isMACAddress(string){
+        return new Str(string).isMACAddress();
+    }
+    isPascalCase(){
+        if (this.string.length === 0) return false;
+        const PascalCasePattern = /^[A-Z][a-zA-Z0-9]*$/;
+        return PascalCasePattern.test(this.string);
+    }
+    static isPascalCase(string){
+        return new Str(string).isPascalCase();
+    }
+    isCamelCase() {
+        if (this.string.length === 0) return false;        
+        const camelCasePattern = /^[a-z][a-zA-Z0-9]*$/;
+        return camelCasePattern.test(this.string);
+    }
+    static isCamelCase(string){
+        return new Str(string).isCamelCase();
+    }
+    isHyphenCase(){
+        return this.string.split('-').length > 1;
+    }
+    static isHyphenCase(string){
+        return new Str(string).isHyphenCase();
+    }
+    isSnakeCase(){
+        return this.string.split('_').length > 1;
+    }
+    static isSnakeCase(string){
+        return new Str(string).isSnakeCase();
+    }
+    isPalindrome(){
+        const str=this.string.toLocaleLowerCase();
+        let l=str.length,i;
+        for(i=0;i<l/2;i++)if(str[i]!=str[l-i-1])return false;
+        return true;
+    }
+    static isPalindrome(string){
+        return new Str(string).isPalindrome();
+    }
+    static isAnagrams(word,words){
+        word=word.split("").sort();
+        words=words.split("").sort();
+        return JSON.stringify(word)===JSON.stringify(words);
+    }
+    isIsogram(){
+        return [...new Set(this.string.toLowerCase())].length===this.string.length; 
+    }
+    static isIsogram(string){
+       return  new Str(string).isIsogram();
+    }
+    static camel2hyphencase(text) {
+        return text.replace(/[A-Z]/g, match => '-' + match.toLowerCase());
+    }
+    static camel2snakecase(text) {
+        return text.replace(/[A-Z]/g, match => '_' + match.toLowerCase());
+    }
+    static camel2pascalcase(text) {
+        return text.charAt(0).toUpperCase() + text.slice(1);
+    }
+    static camel2constantcase(text) {
+        return text.replace(/[A-Z]/g, match => '_' + match).toUpperCase();
+    }
+    static pascal2snakecase(text) {
+        return text.replace(/([A-Z])/g, (match, offset) => offset ? '_' + match.toLowerCase() : match.toLowerCase());
+    }
+    static pascal2hyphencase(text) {
+        return text.replace(/([A-Z])/g, (match, offset) => offset ? '-' + match.toLowerCase() : match.toLowerCase());
+    }
+    static pascal2camelcase(text) {
+        return text.charAt(0).toLowerCase() + text.slice(1);
+    }
+    static pascal2constantcase(text) {
+        return text.replace(/([A-Z])/g, (match, offset) => offset ? '_' + match : match).toUpperCase();
+    }
+    static snake2camelcase(text) {
+        return text.replace(/(_\w)/g, match => match[1].toUpperCase());
+    }
+    static snake2hyphencase(text) {
+        return text.replace(/_/g, "-");
+    }
+    static snake2pascalcase(text) {
+        return text.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('');
+    }
+    static snake2constantcase(text) {
+        return text.toUpperCase();
+    }
+    static hyphen2camelcase(text) {
+        return text.replace(/-([a-z])/g, match => match[1].toUpperCase());
+    }
+    static hyphen2snakecase(text) {
+        return text.replace(/-/g, '_');
+    }
+    static hyphen2pascalcase(text) {
+        return text.split('-').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('');
+    }
+    static hyphen2constantcase(text) {
+        return text.replace(/-/g, '_').toUpperCase();
+    }
+    static constant2camelcase(text) {
+        return text.toLowerCase().replace(/_([a-z])/g, match => match[1].toUpperCase());
+    }
+    static constant2snakecase(text) {
+        return text.toLowerCase();
+    }
+    static constant2pascalcase(text) {
+        return text.toLowerCase().split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('');
+    }
+    static constant2hyphencase(text) {
+        return text.toLowerCase().replace(/_/g, '-');
+    }
+}
+const removeExtraSpace=str=>str.replace(/\s+/g,' ');
+const count=(str,value)=>str.split("").filter(x => x==value).length;
+const countWords=(str,value)=>str.split(" ").filter(x => x==value).length;
+
+export{
+    removeExtraSpace,
+    count,
+    countWords
+}
+const str=string=>new Str(string);
+export{
+    Str,
+    str
+}

package/src/graphics/canvas/canvas.js

@@ -0,0 +1,189 @@
+import ZikoUIContainerElement from "../../user-interface/elements/primitives/ZikoUIContainerElement.js";
+import {Matrix} from "../../math/matrix/index.js"
+import { convolute } from "../../math/signal/conv.js";
+class ZikoUICanvas extends ZikoUIContainerElement{
+    constructor(w,h){
+        super("canvas","canvas");
+        //this.element=document?.createElement("canvas");
+        this.ctx = this.element?.getContext("2d");
+        this.style({
+            border:"1px red solid",
+            //width:"300px",
+            //height:"300px"
+        })
+        this.transformMatrix=new Matrix([
+            [1,0,0],
+            [0,1,0],
+            [0,0,1]
+        ])
+        this.axisMatrix=new Matrix([
+            [-10,-10],
+            [10,10]
+        ])
+        // this.render(globalThis.__Ziko__.__Config__.default.render);
+        setTimeout(()=>this.resize(w,h),0);
+        this.on("sizeupdated",()=>this.adjust())
+    }
+    get Width(){
+        return this.element?.width;
+    }
+    get Height(){
+        return this.element?.height;
+    }
+    get Xmin(){
+        return this.axisMatrix[0][0];
+    }
+    get Ymin(){
+        return this.axisMatrix[0][1];
+    }
+    get Xmax(){
+        return this.axisMatrix[1][0];
+    }
+    get Ymax(){
+        return this.axisMatrix[1][1];
+    }
+    get ImageData(){
+        return this.ctx.getImageData(0,0,c.Width,c.Height);
+    }
+    draw(all=true){
+        if(all){
+            this.clear();  
+            this.items.forEach(element => {
+                element.parent=this;
+                element.draw(this.ctx)
+            });
+        }
+        else {
+            this.items.at(-1).parent=this;
+            this.items.at(-1).draw(this.ctx);
+        }
+        this.maintain();
+        return this;
+    }
+    applyTransformMatrix(){
+        this.ctx.setTransform(
+            this.transformMatrix[0][0],
+            this.transformMatrix[1][0],
+            this.transformMatrix[0][1],
+            this.transformMatrix[1][1],
+            this.transformMatrix[0][2],
+            this.transformMatrix[1][2],
+        );
+        return this;
+    }
+    resize(w,h){
+        // this.style({
+        //     width:w,
+        //     height:h
+        // })
+        this.size(w,h)
+        this.lineWidth();
+        this.view(this.axisMatrix[0][0], this.axisMatrix[0][1], this.axisMatrix[1][0], this.axisMatrix[1][1]);
+        this.emit("sizeupdated");
+        return this;
+    }
+    adjust(){
+        this.element.width =this.element?.getBoundingClientRect().width;
+        this.element.height =this.element?.getBoundingClientRect().height;
+        this.view(this.axisMatrix[0][0], this.axisMatrix[0][1], this.axisMatrix[1][0], this.axisMatrix[1][1]);
+        return this;
+    }
+    view(xMin,yMin,xMax,yMax){
+        this.transformMatrix[0][0]=this.Width/(xMax-xMin); // scaleX
+        this.transformMatrix[1][1]=-this.Height/(yMax-yMin); // scaleY
+        this.transformMatrix[0][2]=this.Width/2;
+        this.transformMatrix[1][2]=this.Height/2;
+        this.axisMatrix=new Matrix([
+            [xMin,yMin],
+            [xMax,yMax]
+        ])
+        
+        this.applyTransformMatrix(); 
+        this.clear();
+        this.lineWidth(1);
+        this.draw();
+        return this;
+    }
+    reset(){
+        this.ctx.setTransform(1,0,0,0,0,0);
+        return this;
+    }
+    append(element){
+        this.items.push(element);
+        this.draw(false);
+        return this;
+    }
+    background(color){
+        this.ctx.fillStyle = color;
+        this.ctx.setTransform(1, 0, 0, 1, 0, 0);
+        this.ctx.fillRect(0, 0, this.Width, this.Height);
+        this.applyTransformMatrix();
+        this.draw();
+    }
+    lineWidth(w){
+        this.ctx.lineWidth=w/this.transformMatrix[0][0];;
+        return this
+    }
+    ImageData(x=0,y=0,w=this.Width,h=this.Height){
+        return this.ctx.getImageData(x,y,w,h);
+    }
+    clear(){
+        this.ctx.setTransform(1, 0, 0, 1, 0, 0);
+        this.ctx.clearRect(0, 0, this.Width, this.Height);
+        this.applyTransformMatrix(); 
+        return this;
+    }
+    clone(){
+        console.log(this.Width)
+        const canvas=new ZikoUICanvas();
+        canvas.items=this.items;
+        canvas.transformMatrix=this.transformMatrix;
+        canvas.axisMatrix=this.axisMatrix;
+        Object.assign(canvas.cache,{...this.cache});
+        //waitForUIElm(this)
+        //console.log(element)
+        this.size(element.style.width,element.style.width);
+        this.applyTransformMatrix();
+        this.draw();
+        this.adjust();
+        return canvas;
+    }
+    toImage() {
+        this.img = document?.createElement("img");
+        this.img.src = this.element?.toDataURL("image/png");
+        return this;
+    }
+    toBlob() {
+        var canvas = this.element;
+        canvas.toBlob(function (blob) {
+            var newImg = document?.createElement("img"),
+                url = URL.createObjectURL(blob);
+            newImg.onload = function () {
+                URL.revokeObjectURL(url);
+            };
+            newImg.src = url;
+            console.log(newImg);
+        });
+    }
+    zoomIn(){
+
+    }
+    zoomOut(){
+        
+    }
+    undo(n){
+
+    }
+    redo(n){
+
+    }
+    stream(){
+
+    }
+}
+
+const Canvas=(w,h)=>new ZikoUICanvas(w,h);
+export{
+    ZikoUICanvas
+}
+export default Canvas;