sheel-deer 1.0.0

package/src/classes/BinaryData.ts

@@ -0,0 +1,81 @@
+import { equal, fromAscii } from '../methods/parsers';
+import { DataList } from '../models/data-type-model';
+import { TemplateBinary } from '../models/template-binary-model';
+import { getStreamModel } from './DataModel';
+
+export class BinaryData{
+    replaceBinaryData = (array: number[], replace: number[]) => {
+        let data: DataList = new DataList();
+
+        let i = 0;
+        for(let num of array){
+            if(num == 32){
+                i++
+            }else{
+                data.list[i].array = [...data.list[i].array, num];
+            }
+
+        }
+
+        let result = [] as number[];
+
+        for(let array of data.list){
+            if(!equal(array.array, replace)){
+                result = [...result, ...array.array];
+            }
+        }
+
+        return result;
+    }
+
+    setTemplateBinaryData = (startIndex: number, endIndex: number, number: number[]) => {
+        const streamModel = getStreamModel();
+        const data = streamModel.data;
+
+        if (startIndex < 0 || endIndex < startIndex || endIndex > data.length) {
+            throw new Error(`Invalid template replacement range: ${startIndex}-${endIndex}`);
+        }
+
+        streamModel.data = [
+            ...data.slice(0, startIndex),
+            ...number,
+            ...data.slice(endIndex)
+        ];
+
+        return streamModel;
+    }
+
+    getTemplateBinaryDataDirective = (index: number, start: number, directive: TemplateBinary) : number  => {
+        const streamModel = getStreamModel();
+        console.log(fromAscii(streamModel.data));
+        const data = streamModel.data;
+        const pattern = directive.bitMap;
+
+        for (let i = index; i <= data.length - pattern.length; i++) {
+            let match = true;
+            for (let j = 0; j < pattern.length; j++) {
+                if (data[i + j] !== pattern[j]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                return i + pattern.length;
+            }
+        }
+
+        throw new Error(`Directive ${directive.name} not found in stream`);
+    }
+
+    getTemplateBinaryData = (start: number, end: number) => {
+        const streamModel = getStreamModel();
+        let binary = [] as number[];
+        for(let i = start; i < end; i++) {
+            const charCode = streamModel.data[i];
+
+            binary = [...binary, charCode];
+        }
+
+        return binary;
+    }
+}

package/src/classes/DataModel.ts

@@ -0,0 +1,386 @@
+import { DataStream } from '../models/data-stream';
+import { DataComponentModel } from '../models/data-type-model';
+import { DataTypes } from './DataTypes';
+import { asciiTable } from './../data/ascii';
+import ts from "typescript";
+import { returnCssLinkByteArray, translateTS,createPage, fromPage, returnJSLinkByteArray, nestedComponents, fromString, fromAscii, fromPageToString, createFromString } from './../methods/parsers';
+import fs from 'fs';
+import path from 'path';
+import { initComponent } from '../../init-start-page';
+import { getCurrentSquaring, Squaring } from '../components/squaring';
+import { flatList } from '../methods/array-helpers';
+import { ContentFile } from '../models/ascii';
+import { HtmlTemplate } from './../methods/html-template';
+import { newRow, pageEnd, pageStart } from '../data/binary-resources';
+import { TemplateBinary } from '../models/template-binary-model';
+import { BinaryData } from './BinaryData';
+
+let streamModel = {} as DataStream;
+export let lastStreamModel = {} as DataStream;
+export const getStreamModel = () => streamModel;
+
+export const squaring = new Squaring();
+
+export class DataModel {
+
+    initDataStream = (stream: Buffer | DataStream, saveLast: boolean = false) => {
+        if(saveLast){
+            if (Buffer.isBuffer(stream)) {
+                lastStreamModel = { type: 'buffer', data: Array.from(stream) } as DataStream;
+            } else {
+                lastStreamModel = JSON.parse(JSON.stringify(stream)) as DataStream;
+            }
+        }
+
+        if (Buffer.isBuffer(stream)) {
+            streamModel = { type: 'buffer', data: Array.from(stream) } as DataStream;
+        } else {
+            streamModel = JSON.parse(JSON.stringify(stream)) as DataStream;
+        }
+    }
+
+    returnDataStream = (dataStream: DataStream) => {
+        let buffer = Buffer.from(JSON.stringify(dataStream, null, 2), "utf-8");
+
+        return buffer;
+    }
+        
+    createHTMLPage = (byteArray: number[]) => {
+        let result = "";
+        let depth = 0;
+        let buffer = "";
+
+        const getChar = (byte: number) =>
+            asciiTable.ascii.find(x => x.code === byte)?.char || "";
+
+        const voidTags = new Set([
+            "meta","br","img","input","hr","link",
+            "area","base","col","embed","source","track","wbr"
+        ]);
+
+        for (let i = 0; i < byteArray.length; i++) {
+            const byte = byteArray[i];
+            const char = getChar(byte);
+
+            buffer += char;
+
+            // TAG CLOSED
+            if (byte === 62) { // ">"
+                const tag = buffer.trim();
+                buffer = "";
+
+                const isDoctype = tag.startsWith("<!DOCTYPE");
+                const isClosing = tag.startsWith("</");
+                const isSelfClosing = tag.endsWith("/>");
+
+                const tagName = tag
+                    .replace(/<\/?|\/?>/g, "")
+                    .split(" ")[0]
+                    .toLowerCase();
+
+                const isVoid = voidTags.has(tagName);
+
+                let j = i + 1;
+                let text = "";
+
+                while (j < byteArray.length && byteArray[j] !== 60) {
+                    text += getChar(byteArray[j]);
+                    j++;
+                }
+
+                let closingTag = "";
+                let k = j;
+
+                while (k < byteArray.length && byteArray[k] !== 62) {
+                    closingTag += getChar(byteArray[k]);
+                    k++;
+                }
+                closingTag += ">";
+
+                const isInline =
+                    !isClosing &&
+                    !isSelfClosing &&
+                    !isVoid &&
+                    text.trim().length > 0 &&
+                    closingTag.startsWith(`</${tagName}`);
+
+                if (isClosing) depth--;
+
+                if (isDoctype) {
+                    result += "\n" + tag;
+                }
+                else if (isInline) {
+                    result +=
+                        "\n" +
+                        "\t".repeat(depth) +
+                        tag +
+                        text.trim() +
+                        closingTag;
+
+                    i = k;
+                }
+                else {
+                    result += "\n" + "\t".repeat(depth) + tag;
+
+                    if (!isClosing && !isSelfClosing && !isVoid) {
+                        depth++;
+                    }
+                }
+            }
+        }
+
+        return result.trim();
+    };
+
+
+    createAppModel = (stream: Buffer) => {
+        this.initDataStream(stream);
+
+        let dataTypes = new DataTypes();
+        let appDataModel: DataComponentModel = {
+            template: dataTypes.htmlDataTemplate(),
+            shell: dataTypes.tsDataType(),
+            visual: dataTypes.cssDataType()
+        }
+
+        return appDataModel;
+    }
+
+
+    createComponentModel = (stream: Buffer) => {
+        this.initDataStream(stream, true);
+
+        let dataTypes = new DataTypes();
+        let appDataModel: DataComponentModel = {
+            template: dataTypes.htmlDataTemplate(),
+            shell: dataTypes.tsDataType(),
+            visual: dataTypes.cssDataType()
+        }
+
+        return appDataModel;
+    }
+
+    setHtmlTemplate = (number: number[], currentComponent: string, currentFile?: string) : DataStream => {
+        let dataTypes = new DataTypes();
+        let bodyDataType = dataTypes.bodyDataType();
+        let properties = getCurrentSquaring().find(x=> x.name == currentComponent)?.data.imports[0].properties;
+        
+        let resultStream: DataStream = {
+            type: "",
+            data: number
+        } as DataStream;
+
+        if(properties && properties.length){
+            for(let prop of properties){
+                if(prop.name.trim() != ""){
+                    resultStream = this.setNestedComponent(resultStream.data, prop.name, prop.path);
+                    
+                }
+            }
+        }
+
+        let dataArray = fromAscii(resultStream.data).split('\n');
+        let contentFile = new ContentFile();
+
+        for(let arrayItem of dataArray){
+            let dataRow = fromString(arrayItem);
+            contentFile.contentFile.push(newRow.name);
+            contentFile.contentFile.push(arrayItem);
+        }
+
+        let result = {
+            type: bodyDataType.type,
+            data: number,
+            dataList: createFromString(contentFile)
+        } as DataStream;
+
+        return result;
+    }
+
+    setNestedComponent = (number: number[], name: string, path: string) : DataStream => {
+        let dataTypes = new DataTypes();
+        let component = initComponent(path.replace('./', ''), name);
+        const initDataModel = new DataModel();
+        let dataBody = new DataTypes();
+
+        initDataModel.initDataStream({ type: "", data: number } as DataStream, true);
+
+        let start = fromString(`<${name}>`), end = fromString(`</${name}>`);
+        let startDirective = {name: `<${name}>`, code: start.length, bitMap: start };
+        let endDirective = {name: `</${name}>`, code: end.length, bitMap: end};
+        let customResult = dataBody.customDataType(startDirective, endDirective);
+
+        let templateResult = dataTypes.writeDataBinary(customResult.startIndex - startDirective.code, customResult.endIndex + endDirective.code, component.template.byteTemplate);
+
+        initDataModel.initDataStream(lastStreamModel);
+
+        console.log(fromAscii(templateResult.data))
+        return templateResult;
+
+    }   
+
+
+
+    setTsTemplate = (number: number[], cssPage: string) : DataStream => {
+
+        let result = translateTS(number, cssPage);
+
+        return {
+            type: 'ts',
+            data: flatList(result),
+            dataList: result
+        };
+    }
+
+    getEvents = (number: number[], name: string) => {
+        let content = fromAscii(number);
+        let events: string[] = [];
+
+        for(let i = 0; i < content.length; i++){
+            let char = content[i];
+            let event = false;
+            let item = '';
+            if(char == "@"){
+                event = true
+                item += char;
+            }
+
+            if(event){
+                item += char;
+            }
+
+            if(char == ")" && content[i + 1] == '"' && event){
+                item += char;
+                event = false;
+            }
+
+            content.replace('item', '');
+            
+            events = [...events, item];
+        }
+
+        for(let item of events){
+
+            const match = item.match(/@(\w+)="(\w+)\(([^)]*)\)"/);
+
+            if (match) {
+                const eventType = match[1];     // click
+                const methodName = match[2];    // handleClick
+                const argument = match[3];      // $event
+
+                squaring.updateNotationType(methodName, eventType);
+            }
+
+        }
+
+        return fromString(content);
+    }
+
+    private runTsChecks = (content: string): string => {
+        const check = ts.transpileModule(content, {
+            compilerOptions: {
+                module: ts.ModuleKind.CommonJS,
+                target: ts.ScriptTarget.ES2020,
+            },
+            reportDiagnostics: true,
+        });
+
+        if (check.diagnostics?.length) {
+            console.error(
+                check.diagnostics.map(d =>
+                    ts.flattenDiagnosticMessageText(d.messageText, "\n")
+                )
+            );
+        }
+
+        return check.outputText;
+    }
+
+    createTsTemplate = (
+        number: number[],
+        page: string,
+        cssPage: string,
+        headers: string[] = [],
+        bootstrap: boolean = true
+    ): DataStream => {
+
+        if(cssPage === "App"){
+            // Copy './base/Component.ts' to 'public/Component.ts' as-is
+            const dir = path.join(__dirname, "public");
+            const filePath = path.join(dir, `Component.ts`);
+            const srcPath = path.join(__dirname, '..',  './src/classes/public/Component.ts');
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            if (fs.existsSync(srcPath)) {
+                fs.copyFileSync(srcPath, filePath);
+            }
+        }
+
+        const initPage = bootstrap ? fromPage(`let page = new ${cssPage}();`) : [];
+
+        let result = this.setTsTemplate(number, cssPage);
+
+        let compiledFile = createPage(result.dataList);
+
+        const dir = path.join(__dirname, "public");
+        const filePath = path.join(dir, `${page}.ts`);
+
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, compiledFile, "utf8");
+
+        const outText = this.runTsChecks(compiledFile);
+
+
+        const outPath = filePath.replace(/\.ts$/, ".js");
+        fs.writeFileSync(outPath, outText, "utf8");
+
+        return result;
+    };
+
+
+    createHtmlTemplate = (number: number[], page: string, cssPage: string, currentFile?: string) : DataStream => {
+        let result = this.setHtmlTemplate(number, cssPage, currentFile);
+
+        let htmlTemplate = createPage(result.dataList);
+
+        const dir = path.join(__dirname, "public");
+        const filePath = path.join(dir, `${page}.html`);
+
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        let content = fromPageToString(result.data);
+        content = content.replace(/<visual>[\s\S]*?<\/visual>/g, "");
+
+        let html = new HtmlTemplate()
+
+        fs.writeFileSync(filePath, html.createHtmlTemplate(
+            {
+                bodyContent: htmlTemplate
+            }
+        ), "utf8");
+
+        return result;
+    }
+        
+    createCssTemplate = (bytes: number[], page: string) => {
+        const dir = path.join(__dirname, "public");
+        const filePath = path.join(dir, `${page}.css`);
+
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        let content = fromPageToString(bytes);
+
+        fs.writeFileSync(filePath, content, "utf8");
+    };
+
+    createCSSPage = (byteArray: number[]) => {
+        return byteArray;
+    }
+}

package/src/classes/DataTypes.ts

@@ -0,0 +1,116 @@
+
+import { dataVisualStart, dataVisualEnd, pageStart, dataCodeStart, dataCodeEnd, dataBodyStart, dataBodyEnd, dataHeadStart, dataHeadEnd, pageEnd } from "../data/binary-resources";
+import { DataStream } from "../models/data-stream";
+import { DataComponentModel, DataTypeModel } from "../models/data-type-model";
+import { BinaryData } from './BinaryData';
+
+export class DataTypes {
+    initDataTypes() {
+        let app = { 
+            template: this.htmlDataTemplate(),
+            shell: this.tsDataType(),
+            visual: this.cssDataType()
+        } as DataComponentModel;
+        
+        return app;
+    }
+
+    writeDataBinary = (startIndex:number, endIndex: number, number: number[]) : DataStream => {
+        let binaryData = new BinaryData();
+
+        let result = binaryData.setTemplateBinaryData(startIndex, endIndex, number);
+        
+        return result;
+    }
+
+    headDataType = () : DataTypeModel => {
+        let binaryData = new BinaryData();
+        let startIndex = binaryData.getTemplateBinaryDataDirective(0, 0, dataHeadStart);
+        let endIndex = binaryData.getTemplateBinaryDataDirective(0, 0, dataHeadEnd) - dataHeadEnd.bitMap.length;
+
+        return {
+            name: 'head',
+            type: 'head-attr',
+            byteTemplate: binaryData.getTemplateBinaryData(startIndex, endIndex),
+            startIndex: startIndex,
+            endIndex: endIndex
+        }
+    }
+
+    customDataType = (customDataStart :{ name: string; code: number; bitMap: number[]; }, customDataEnd:{ name: string; code: number; bitMap: number[];}) : DataTypeModel => {
+        let binaryData = new BinaryData();
+        let startIndex = binaryData.getTemplateBinaryDataDirective(0, 0, customDataStart);
+        let endIndex = binaryData.getTemplateBinaryDataDirective(0, 0, customDataEnd) - customDataEnd.bitMap.length;
+        
+        return {
+            name: customDataStart.name,
+            type: customDataStart.name + '-page',
+            byteTemplate: binaryData.getTemplateBinaryData(startIndex, endIndex),
+            startIndex: startIndex,
+            endIndex: endIndex
+        }
+    }
+
+    bodyDataType = () : DataTypeModel => {
+        let binaryData = new BinaryData();
+        let startIndex = binaryData.getTemplateBinaryDataDirective(0, 0, dataBodyStart);
+        let endIndex = binaryData.getTemplateBinaryDataDirective(0, 0, dataBodyEnd) - dataBodyEnd.bitMap.length;
+        
+        return {
+            name: 'index',
+            type: 'index-page',
+            byteTemplate: binaryData.getTemplateBinaryData(startIndex, endIndex),
+            startIndex: startIndex,
+            endIndex: endIndex
+        }
+    }
+
+    cssDataType =(): DataTypeModel => {
+        let binaryData = new BinaryData();
+        let startIndex = binaryData.getTemplateBinaryDataDirective(0, 0, dataVisualStart);
+        let endIndex = binaryData.getTemplateBinaryDataDirective(0, 0, dataVisualEnd) - dataVisualEnd.bitMap.length;
+        
+        return {
+            name: 'css',
+            type: 'css-template',
+            byteTemplate: binaryData.getTemplateBinaryData(startIndex, endIndex),
+            startIndex: startIndex,
+            endIndex: endIndex
+        }
+    }
+
+    htmlDataTemplate = (): DataTypeModel => {
+        let binaryData = new BinaryData();
+        let startIndex = binaryData.getTemplateBinaryDataDirective(0, 0, pageStart);
+        let endIndex;
+        try{
+            endIndex = binaryData.getTemplateBinaryDataDirective(0, 0, dataCodeStart) - pageStart.code;
+
+        }catch(ex){
+            endIndex = binaryData.getTemplateBinaryDataDirective(0, 0, pageEnd) - pageStart.code
+        }
+        
+        return {
+            name: 'html',
+            type: 'html-template',
+            byteTemplate: binaryData.getTemplateBinaryData(startIndex, endIndex),
+            startIndex: startIndex,
+            endIndex: endIndex
+        }
+    }
+
+
+    tsDataType: () => DataTypeModel = () => {
+        let binaryData = new BinaryData();
+        let startIndex = binaryData.getTemplateBinaryDataDirective(0, 0, dataCodeStart);
+        let endIndex = binaryData.getTemplateBinaryDataDirective(0, 0, dataCodeEnd) - dataCodeEnd.bitMap.length;
+        
+        return {
+            name: 'ts',
+            type: 'ts-template',
+            byteTemplate: binaryData.getTemplateBinaryData(startIndex, endIndex),
+            startIndex: startIndex,
+            endIndex: endIndex
+        }
+    }
+}