@needle-tools/needle-component-compiler 1.9.1-exp → 1.9.2-exp

package/Changelog.md

@@ -4,7 +4,7 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## [1.9.1-exp] - 2022-11-12
+## [1.9.2-exp] - 2022-11-12
 - Add first version of blender scheme compiler
 
 ## [1.9.1] - 2022-11-05

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "1.9.1-exp",
+    "version": "1.9.2-exp",
     "description": "Compile mock unity components from typescript",
     "main": "index.js",
     "scripts": {

package/src/base-compiler.js

@@ -70,11 +70,12 @@ var CodeTextWriter = /** @class */ (function () {
         if (!fs.existsSync(directory)) {
             fs.mkdirSync(directory, { recursive: true });
         }
+        console.log("Writing " + filename + " to " + directory);
         var content = this.lines.join("\r");
         this.lines.length = 0;
-        var fullPath = fs.realpathSync(directory + "/" + filename);
+        var fullPath = directory + "/" + filename;
         fs.writeFileSync(fullPath, content);
-        return fullPath;
+        return fs.realpathSync(fullPath);
     };
     return CodeTextWriter;
 }());

package/src/watcher.js

@@ -14,8 +14,8 @@ var DirectoryWatcher = /** @class */ (function () {
     }
     DirectoryWatcher.prototype.startWatching = function (dir, writer) {
         var _this = this;
-        console.log("Start watching", dir);
-        chokidar.watch(dir + "/test.ts").on('all', function (event, path) {
+        // console.log("Start watching", dir);
+        chokidar.watch(dir + "/**/*.ts").on('all', function (event, path) {
             try {
                 switch (event) {
                     case "add":
@@ -57,7 +57,8 @@ if (args.length < 2) {
     console.error("Missing arguments, usage: node watcher.js <directory> <output>");
     process.exit(1);
 }
-var directoryToWatch = args[0];
-var outputDirectory = args[1];
+var directoryToWatch = args[0].replace("\"", "");
+var outputDirectory = args[1].replace("\"", "");
+console.log("Watch: " + directoryToWatch + " and output to: " + outputDirectory);
 var watcher = new DirectoryWatcher();
 watcher.startWatching(directoryToWatch, new blender_compiler_1.BlenderWriter(outputDirectory));

package/COMPILE.bat

@@ -1 +0,0 @@
-npm run tsc src/component-compiler

package/DEV.bat

@@ -1 +0,0 @@
-npm install && npm run dev

package/INSTALL.bat

@@ -1 +0,0 @@
-npm install && timeout 10

package/PUBLISH.bat

@@ -1,8 +0,0 @@
-@echo off
-echo Press a key to publish! (close the window if you changed your mind)
-pause
-echo Publishing in 2 sec
-timeout 2
-npm run compile & npm set registry https://registry.npmjs.org && npm publish & pause
-echo Finished...
-timeout 10

package/RUN_MANUAL_BLENDER.bat

@@ -1 +0,0 @@
-npm run tsc src/blender-compiler && node src/blender-compiler.js dist src/test.ts

package/RUN_MANUAL_TEST.bat

@@ -1 +0,0 @@
-npm run tsc src/component-compiler && node src/component-compiler.js dist src/test.ts

package/RUN_TESTS.bat

@@ -1 +0,0 @@
-npm run test & pause

package/RUN_WATCHERS.bat

@@ -1 +0,0 @@
-npm run tsc src/watcher && node src/watcher.js

package/schemes/MyTestComponent.component.json

@@ -1 +0,0 @@
-{
    "MyTestComponent": {
        "myMethod": {
            "type": "fn"
        },
        "myEvent": {
            "type": "evt"
        },
        "myNumber": {
            "type": "float",
            "value": 1
        }
    }

package/src/base-compiler.ts

@@ -1,422 +0,0 @@
-import { readFileSync } from "fs";
-import * as ts from "typescript";
-import * as fs from "fs";
-
-export enum Visibility {
-    Public = 0,
-    Protected = 1,
-    Private = 2,
-}
-
-declare type Argument = {
-    name: string;
-    type: string;
-    defaultValue?: string;
-}
-
-export class CodeTextWriter {
-    private indent: number = 0;
-    private lines: string[] = [];
-
-    beginBlock(line: string) {
-        this.writeLine(line);
-        this.indent++;
-    }
-    endBlock(line: string) {
-        // remove the comma from the last line
-        if (this.lines.length > 0) {
-            const prevLine = this.lines[this.lines.length - 1];
-            if (prevLine.endsWith(",")) {
-                this.lines[this.lines.length - 1] = prevLine.substring(0, prevLine.length - 1);
-            }
-        }
-
-        this.indent--;
-        this.writeLine(line);
-    }
-    writeLine(line: string) {
-        let indent = "";
-        for (let i = 0; i < this.indent; i++) {
-            indent += "    ";
-        }
-        // remove whitespace so we can ensure we correctly end with a comma
-        this.lines.push(indent + line?.trim());
-    }
-    write(text: string) {
-        const lines = text.split("\r");
-        if (lines.length > 1) {
-            for (let i = 0; i < lines.length; i++) {
-                this.writeLine(lines[i]);
-            }
-        } else {
-            if (this.lines.length == 0) {
-                this.writeLine(text);
-            }
-            else {
-                const lastLine = this.lines[this.lines.length - 1];
-                this.lines[this.lines.length - 1] = lastLine + text;
-            }
-        }
-    }
-    beginArray() {
-        this.writeLine("[");
-        this.indent++;
-    }
-    insertArrayItem(item: string) {
-        this.writeLine(item + ",");
-    }
-    endArray() {
-
-    }
-
-    flush(directory: string, filename: string): string | void {
-        if(this.lines.length === 0) return;
-        if (!fs.existsSync(directory)) {
-            fs.mkdirSync(directory, { recursive: true });
-        }
-        const content = this.lines.join("\r");
-        this.lines.length = 0;
-        const fullPath = fs.realpathSync(directory + "/" + filename);
-        fs.writeFileSync(fullPath, content);
-        return fullPath;
-    }
-}
-
-export interface IWriter {
-    resolveTypeName(typescriptTypeName: string): string | void;
-    begin(): void;
-    end(): void;
-    startNewType(typeName: string, baseType: string, comments?: string[]): void | boolean;
-    endNewType(typeName: string): void;
-    writeMember(visibility: Visibility, name: string, isArray: boolean, type: string, initialValue?: string, comments?: string[]): void
-    writeMethod(visibility: Visibility, name: string, returnType: string | undefined, args: Argument[], comments: string[]): void
-    writeNewTypeExpression(typeName: string, args?: string[]): void;
-}
-
-export function runFromFile(writer: IWriter, path: string): Compiler {
-    if (!fs.existsSync(path)) {
-        console.error("File not found", path);
-        return;
-    }
-    const code = readFileSync(path).toString();
-    const compiler = new Compiler();
-    compiler.compile(writer, code);
-    return compiler;
-}
-
-export class Compiler {
-
-
-    compile(writer: IWriter, code: string) {
-        const file = "needle_compiled.ts";
-        const sourceFile = ts.createSourceFile(
-            file,
-            code,
-            ts.ScriptTarget.ES2015,
-            true, /*setParentNodes */
-            ts.ScriptKind.TS
-        );
-        const prog = ts.createProgram([file], {});
-        this.run(prog, writer, sourceFile);
-    }
-
-    private run(prog: ts.Program, writer: IWriter, sourceFile: ts.SourceFile) {
-        writer.begin();
-        ts.forEachChild(sourceFile, (node) => {
-            this.visit(node, writer);
-        });
-        writer.end();
-    }
-
-    private visit(node: ts.Node, writer: IWriter) {
-        if (ts.isClassDeclaration(node)) {
-            this.visitClassDeclaration(node, writer);
-        }
-        else if (ts.isPropertyDeclaration(node)) {
-            this.visitPropertyDeclaration(node, writer);
-        }
-        else if (ts.isMethodDeclaration(node)) {
-            this.visitMethodDeclaration(node, writer);
-        }
-        else {
-            ts.forEachChild(node, (node) => {
-                this.visit(node, writer);
-            });
-        }
-    }
-
-    private visitClassDeclaration(node: ts.ClassDeclaration, writer: IWriter) {
-        const name = node.name.text;
-        const base = node.heritageClauses && node.heritageClauses[0].types[0].expression.getText();
-        this.debugLog("CLASS START", name, base);
-        const res = writer.startNewType(name, base, this.getComments(node));
-        if (res === false) {
-            this.debugLog("CLASS SKIPPED", name);
-            return;
-        }
-        ts.forEachChild(node, (node) => {
-            this.visit(node, writer);
-        });
-        writer.endNewType(name);
-        this.debugLog("CLASS END", name, "\n");
-    }
-
-    private visitPropertyDeclaration(node: ts.PropertyDeclaration, writer: IWriter) {
-        const name = node.name.getText();
-        let type = this.resolveType(node.type, writer);
-        const visibility = this.getVisibility(node);
-        const initialValue = node.initializer && this.resolveExpression(node.initializer, writer);
-        const isArray = this.isArrayType(node.type);
-        if (!type && node.initializer) {
-            type = this.tryResolveTypeFromExpression(node.initializer, writer);
-        }
-        this.debugLog("PROPERTY", Visibility[visibility], name, isArray, type, initialValue);
-        writer.writeMember(visibility, name, isArray, type, initialValue, this.getComments(node));
-    }
-
-    private visitMethodDeclaration(node: ts.MethodDeclaration, writer: IWriter) {
-        const name = node.name.getText();
-        const visibility = this.getVisibility(node);
-        const returnType = this.resolveType(node.type, writer);
-        let args: Argument[] | undefined;
-        if (node.parameters?.length) {
-            args = this.resolveParameters(node.parameters, writer);
-        }
-        this.debugLog("METHOD", Visibility[visibility], name, returnType, args);
-        writer.writeMethod(visibility, name, returnType, args, this.getComments(node));
-    }
-
-    private resolveParameters(parameters: ts.NodeArray<ts.ParameterDeclaration>, writer: IWriter): Argument[] {
-        const result: Argument[] = [];
-        for (const parameter of parameters) {
-            const name = parameter.name.getText();
-            const type = this.resolveType(parameter.type, writer);
-            const defaultValue = parameter.initializer && this.resolveExpression(parameter.initializer, writer);
-            result.push({ name, type, defaultValue });
-        }
-        return result;
-    }
-
-    private debugLog(...args: any[]) {
-        console.log(...args);
-    }
-
-    private getComments(node: ts.Node): string[] | undefined {
-        const commentRanges = ts.getLeadingCommentRanges(node.getFullText(), 0);
-        if (commentRanges) {
-            const comments: string[] = [];
-            for (const range of commentRanges) {
-                const text = node.getFullText().substring(range.pos, range.end).trimStart();
-                // match only lines that starts with //@ or // @
-                const match = text.match(/\/\/\s*@(.+)/);
-                if (match) {
-                    comments.push(text.substring(match.index + 2).trim());
-                }
-            }
-            return comments;
-        }
-    }
-
-    private getVisibility(node: ts.PropertyDeclaration | ts.MethodDeclaration): Visibility {
-        if (node.modifiers) {
-            for (const modifier of node.modifiers) {
-                if (modifier.kind === ts.SyntaxKind.PublicKeyword) {
-                    return Visibility.Public;
-                }
-                else if (modifier.kind === ts.SyntaxKind.ProtectedKeyword) {
-                    return Visibility.Protected;
-                }
-                else if (modifier.kind === ts.SyntaxKind.PrivateKeyword) {
-                    return Visibility.Private;
-                }
-            }
-        }
-        return Visibility.Public;
-    }
-
-    private tryResolveTypeFromExpression(exp: ts.Expression, write: IWriter): string | undefined {
-        if (ts.isNewExpression(exp)) {
-            // try get generic type from expression
-            if (exp.typeArguments?.length) {
-                for (const arg of exp.typeArguments) {
-                    const type = this.resolveType(arg, write);
-                    if (type) {
-                        return type;
-                    }
-                }
-            }
-
-
-            const typeName = exp.expression.getText();
-            // const typeName = exp.expression.getText();
-            // console.log("NEW EXPRESSION", typeName);
-            // const args = exp.arguments?.map(arg => this.resolveExpression(arg, write));
-            // write.writeNewTypeExpression(typeName, args);
-            return typeName;
-        }
-    }
-
-    private resolveType(typeNode: ts.TypeNode, writer: IWriter): string | undefined {
-        if (!typeNode) return undefined;
-        // check if its an array
-        if (this.isArrayType(typeNode)) {
-            if (typeNode.kind === ts.SyntaxKind.ArrayType) {
-                const arrayType = typeNode as ts.ArrayTypeNode;
-                return this.resolveType(arrayType.elementType, writer);
-            }
-            // check if its Array<> or Map
-            if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-                const typeReference = typeNode as ts.TypeReferenceNode;
-                if (typeReference.typeName.getText() === "Array") {
-                    const typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
-                    return this.resolveType(typeArgument, writer);
-                }
-                else if (typeReference.typeName.getText() === "Map") {
-                    const typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
-                    return this.resolveType(typeArgument, writer);
-                }
-            }
-            // check if its dictionary
-            if (typeNode.kind === ts.SyntaxKind.TypeLiteral) {
-                const typeLiteral = typeNode as ts.TypeLiteralNode;
-                const members = typeLiteral.members;
-                if (members.length === 2) {
-                    const firstMember = members[0];
-                    const secondMember = members[1];
-                    if (firstMember.kind === ts.SyntaxKind.IndexSignature && secondMember.kind === ts.SyntaxKind.IndexSignature) {
-                        const firstIndexSignature = firstMember as ts.IndexSignatureDeclaration;
-                        const secondIndexSignature = secondMember as ts.IndexSignatureDeclaration;
-                        const firstIndexType = firstIndexSignature.parameters[0].type;
-                        const secondIndexType = secondIndexSignature.parameters[0].type;
-                        if (firstIndexType.kind === ts.SyntaxKind.StringKeyword && secondIndexType.kind === ts.SyntaxKind.NumberKeyword) {
-                            const valueType = firstIndexSignature.type;
-                            return this.resolveType(valueType, writer);
-                        }
-                    }
-                }
-            }
-            // is generic
-            // if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-            //     const typeReference = typeNode as ts.TypeReferenceNode;
-            //     const typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
-            //     return this.resolveType(typeArgument, writer);
-            // }
-            console.error("!!!!! ----- Unknown array type", typeNode.getText());
-        }
-        const type = typeNode.getText();
-        return this.resolveTypeFromString(type, writer);
-    }
-
-    private resolveTypeFromString(type: string, writer: IWriter): string | undefined {
-        const resolved = writer.resolveTypeName(type);
-        return resolved || type;
-    }
-
-    private isArrayType(typeNode: ts.TypeNode): boolean {
-        if (!typeNode) return false;
-        // check if its an array
-        if (typeNode.kind === ts.SyntaxKind.ArrayType) {
-            return true;
-        }
-        // check if its Array<> or map
-        if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-            const typeReference = typeNode as ts.TypeReferenceNode;
-            if (typeReference.typeName.getText() === "Array") {
-                return true;
-            }
-            else if (typeReference.typeName.getText() === "Map") {
-                return true;
-            }
-        }
-        // check if its array or dictionary
-        if (typeNode.kind === ts.SyntaxKind.TypeLiteral) {
-            const typeLiteral = typeNode as ts.TypeLiteralNode;
-            if (typeLiteral.members.length === 2) {
-                const first = typeLiteral.members[0];
-                const second = typeLiteral.members[1];
-                if (first.kind === ts.SyntaxKind.IndexSignature && second.kind === ts.SyntaxKind.IndexSignature) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    private resolveExpression(node: ts.Expression, writer: IWriter): string | undefined {
-        if (ts.isStringLiteral(node)) {
-            return this.resolveTypeFromString(node.text, writer);
-        }
-        else if (ts.isNumericLiteral(node)) {
-            return this.resolveTypeFromString(node.text, writer);
-        }
-        else if (ts.isIdentifier(node)) {
-            return this.resolveTypeFromString(node.text, writer);
-        }
-        // is true or false
-        else if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) {
-            return this.resolveTypeFromString(node.getText(), writer);
-        }
-        else if (ts.isPropertyAccessExpression(node)) {
-            const left = this.resolveExpression(node.expression, writer);
-            if (left) {
-                return left + "." + this.resolveTypeFromString(node.name.text, writer);
-            }
-        }
-        else if (ts.isCallExpression(node)) {
-            const left = this.resolveExpression(node.expression, writer);
-            if (left) {
-                const args = node.arguments.map(a => this.resolveExpression(a, writer)).filter(a => a);
-                return left + "(" + args.join(", ") + ")";
-            }
-        }
-        else if (ts.isBinaryExpression(node)) {
-            const left = this.resolveExpression(node.left, writer);
-            const right = this.resolveExpression(node.right, writer);
-            if (left && right) {
-                return left + " " + node.operatorToken.getText() + " " + right;
-            }
-        }
-        else if (ts.isPrefixUnaryExpression(node)) {
-            const operand = this.resolveExpression(node.operand, writer);
-            if (operand) {
-                return node.operator + operand;
-            }
-        }
-        else if (ts.isPostfixUnaryExpression(node)) {
-            const operand = this.resolveExpression(node.operand, writer);
-            if (operand) {
-                return operand + node.operator;
-            }
-        }
-        else if (ts.isParenthesizedExpression(node)) {
-            return this.resolveExpression(node.expression, writer);
-        }
-        else if (ts.isArrayLiteralExpression(node)) {
-            const elements = node.elements.map(e => this.resolveExpression(e, writer)).filter(e => e);
-            return "[" + elements.join(", ") + "]";
-        }
-        else if (ts.isObjectLiteralExpression(node)) {
-            const properties = node.properties.map(p => {
-                if (ts.isPropertyAssignment(p)) {
-                    const name = p.name.getText();
-                    const value = this.resolveExpression(p.initializer, writer);
-                    if (value) {
-                        return name + ": " + value;
-                    }
-                }
-            }).filter(p => p);
-            return "{" + properties.join(", ") + "}";
-        }
-        else if (ts.isNewExpression(node)) {
-            const typeName = this.resolveTypeFromString(node.expression.getText(), writer);
-            if (typeName) {
-                const args = node.arguments.map(a => this.resolveExpression(a, writer)).filter(a => a);
-                // writer.writeNewTypeExpression(typeName, args);
-                // return;
-                return "new " + typeName + "(" + args.join(", ") + ")";
-            }
-        }
-
-        console.error("!!!!! ----- Unknown expression", ts.SyntaxKind[node.kind], node.getText());
-    }
-}

package/src/blender-compiler.ts

@@ -1,103 +0,0 @@
-import { type } from "os";
-import { isatty } from "tty";
-import { CodeTextWriter, IWriter, runFromFile, Visibility } from "./base-compiler";
-import { sendFileWrittenCommand } from "./commands";
-
-const supportedTypes = ["string", "float", "int", "bool", "col", "obj", "evt", "fn"];
-
-export class BlenderWriter implements IWriter {
-
-    private outputDirectory: string;
-    private writer: CodeTextWriter = new CodeTextWriter();
-
-    constructor(outputDirectory: string) {
-        this.outputDirectory = outputDirectory;
-    }
-
-    resolveTypeName(typeName: string, comments?: string[]): string | void {
-        typeName = typeName.toLocaleLowerCase();
-        if (typeName.startsWith("three."))
-            typeName = typeName.substring("three.".length);
-        switch (typeName) {
-            case "number":
-                return "float";
-            case "int":
-                return "int";
-            case "boolean":
-                return "bool";
-            case "string":
-                return "string";
-            case "void":
-                return "void";
-            case "any":
-                return "any";
-            case "vector2":
-                return "vec2";
-            case "color":
-                return "col";
-            case "renderer":
-                return "comp";
-            case "eventlist":
-                return "evt";
-        }
-    }
-    begin(): void {
-        // this.writer.beginBlock("{")
-    }
-    end(): void {
-        // this.writer.endBlock("}");
-        // this.writer.flush(this.outputFilePath);
-    }
-    startNewType(typeName: string, baseType: string, comments?: string[]): void | boolean {
-        if (baseType !== "Behaviour") return false;
-        this.writer.beginBlock("{")
-        if (comments) console.log(comments);
-        this.writer.beginBlock("\"" + typeName + "\": {");
-    }
-    endNewType(typeName: string): void {
-        this.writer.endBlock("},");
-        this.writer.endBlock("}");
-        this.writeScheme(typeName);
-    }
-    writeMember(visibility: Visibility, name: string, isArray: boolean, type: string, initialValue?: string, comments?: string[]): void {
-        if (!supportedTypes.includes(type)) {
-            console.log("-- unsupported type:", type);
-            return;
-        }
-        this.writer.beginBlock("\"" + name + "\": {");
-        this.writer.writeLine("\"type\": \"" + type + "\",");
-        if (initialValue && !isArray) {
-            if (initialValue.startsWith("new ")) initialValue = undefined;
-            switch (type) {
-                case "bool":
-                    initialValue = initialValue.toLowerCase();
-                    break;
-                case "string":
-                    initialValue = "\"" + initialValue + "\"";
-            }
-            if (initialValue)
-                this.writer.writeLine("\"value\": " + initialValue);
-        }
-        if (isArray) {
-            this.writer.writeLine("\"isArray\": true");
-        }
-        this.writer.endBlock("},");
-    }
-    writeMethod(visibility: Visibility, name: string, returnType: string | undefined, args: { name: string; type: string; defaultValue?: string }[], comments?: string[]): void {
-        this.writer.beginBlock("\"" + name + "\": {");
-        this.writer.writeLine("\"type\": \"fn\",");
-        this.writer.endBlock("},");
-    }
-    writeNewTypeExpression(typeName: string, args?: string[]): void {
-        console.log("new type:", typeName);
-    }
-
-    private writeScheme(component: string) {
-        const outputPath = this.writer.flush(this.outputDirectory, component + ".component.json");
-        if (outputPath)
-            sendFileWrittenCommand(outputPath);
-    }
-
-}
-
-// runFromFile(new BlenderWriter("dist"), "src\\test.ts");

package/src/commands.ts

@@ -1,9 +0,0 @@
-
-
-export function sendReloadCommand(){
-    process.stdout.write("CMD:reload\r");
-}
-
-export function sendFileWrittenCommand(path: string){
-    process.stdout.write("CMD:writefile " + path + "\r");
-}