@bikky/compiler 0.0.79 → 0.1.1

package/Transformers/ReplicableTransformer.js

@@ -0,0 +1,427 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Crawler_js_1 = require("../Source/ASTInterface/Crawler.js");
+const ts = require("typescript");
+const ASTHelper_js_1 = require("../Source/ASTHelper.js");
+const ts_clone_node_1 = require("ts-clone-node");
+const MiscHelpers_js_1 = require("../Source/MiscHelpers.js");
+var printNode = ASTHelper_js_1.Printer.printNode;
+//RBF = Replication Breakdown File.
+const rbfExt = ".rbf.js";
+const defExt = ".data.d.ts";
+const Klasses = new Map;
+let currentFile = null;
+let allFileImports = new Map();
+let replTypeImports = new Map();
+let currentFileAliases = new Map();
+let rbfImports = new Map();
+let defImports = new Map();
+let rbfContents = [];
+function resolveAliases(name) {
+    while (currentFileAliases.has(name)) {
+        name = currentFileAliases.get(name);
+    }
+    return name;
+}
+function makeDataName(name) {
+    return name[0].toUpperCase() + name.slice(1);
+}
+function printRBFClass(klass) {
+    return `
+	Name: ${klass.Name},
+	DataName: ${klass.DataName},
+	Referenced: ${klass.Referenced},
+	Parents: [${klass.Parents.map(p => resolveAliases(p) + "RBF").join(", ")}],
+	AllPropertyNames: [],
+	OwnPropertyNames: [${klass.OwnPropertyNames.sort().map((e) => `"${e}"`).join(", ")}],
+	TypescriptProperties: {${klass.TypescriptProperties.map(p => `
+		${p.propertyName}: ${JSON.stringify(p.rbfType)}`).join(",")}
+	},
+	SerialisedProperties: {${klass.SerialisedProperties.map(p => `
+		${p.propertyName}: ${JSON.stringify(p.rbfType)}`).join(",")}
+	},
+	DataProperties: {${klass.DataProperties.map(p => `
+		${p.propertyName}: {
+			Type: ${JSON.stringify(p.rbfType)},
+			DataName: "${p.dataName}"
+		}`).join(",")}
+	}`.trim() + "\n";
+}
+const warning = `
+// This file is automatically generated by the bikky compiler.
+`.trim();
+Crawler_js_1.Crawler.OnFile((node) => {
+    allFileImports.clear();
+    currentFileAliases.clear();
+    rbfImports.clear();
+    rbfContents = [];
+    currentFile = node.ts;
+});
+Crawler_js_1.Crawler.OnFileCompleted((node => {
+    if (currentFile) {
+        let imports = Array.from(rbfImports.entries()).map(([key, value]) => {
+            value = Array.from(new Set(value));
+            return `import {${value.join(", ")}} from "${key}";`;
+        });
+        imports.push(`import { Replicable } from "@bikky/replication";`);
+        Crawler_js_1.Crawler.writeSupplementaryFile(currentFile.fileName.slice(0, -3) + rbfExt, imports.join("\n") + "\n\n" + warning + "\n\n" +
+            rbfContents.map((e, i) => `export const ${e.Name}RBF = {\n\t${printRBFClass(e)}};\n`
+                + `${e.Name}RBF.AllPropertyNames = ${e.Name}RBF.OwnPropertyNames.concat(${e.Parents.map((e) => `${e}RBF.AllPropertyNames`).join(", ")});\n`
+                + `${e.Name}RBF.AllPropertyNames = Array.from(new Set(${e.Name}RBF.AllPropertyNames)).sort();\n`
+                + `Replicable.registerClass(${e.Name}RBF);`).join("\n\n\n"));
+        imports = Array.from(defImports.entries()).map(([key, value]) => {
+            value = Array.from(new Set(value));
+            return `import {${value.join(", ")}} from "${key}";`;
+        });
+        Crawler_js_1.Crawler.writeSupplementaryFile(currentFile.fileName.slice(0, -3) + defExt, imports.join("\n") + "\n\n" + warning + "\n\n" +
+            rbfContents.map((e) => {
+                if (e.Parents.length > 0) {
+                    return `export interface ${e.Name}Data extends ${e.Parents.map((e) => `Omit<${e + "Data"}, "Class">`).join(", ")} {\n` +
+                        `\tClass: "${e.Name}";\n` +
+                        e.DataProperties.map((p) => `\t"${p.dataName}": ${p.defType};`).join(";\n") +
+                        `\n}\n\n` +
+                        `export interface ${e.Name}Serialised extends ${e.Parents.map((e) => e + "Serialised").join(", ")} {\n` +
+                        `\tversion: string;\n` +
+                        e.SerialisedProperties.map((p) => `\t"${p.propertyName}": ${p.defType};`).join(";\n") +
+                        `\n}\n\n` +
+                        `export interface ${e.Name}Construct extends ${e.Parents.map((e) => e + "Construct").join(", ")} {\n` +
+                        e.TypescriptProperties.map((p) => `\t"${p.dataName}"?: ${p.defType};`).join(";\n") +
+                        `\n}\n`;
+                }
+                else {
+                    return `export interface ${e.Name}Data {\n` +
+                        `\tClass: "${e.Name}";\n` +
+                        e.DataProperties.map((p) => `\t"${p.dataName}": ${p.defType};`).join(";\n") +
+                        `\n}\n\n` +
+                        `export interface ${e.Name}Serialised {\n` +
+                        `\tversion: string;\n` +
+                        e.SerialisedProperties.map((p) => `\t"${p.propertyName}": ${p.defType};`).join(";\n") +
+                        `\n}\n\n` +
+                        `export interface ${e.Name}Construct {\n` +
+                        e.TypescriptProperties.map((p) => `\t"${p.dataName}"?: ${p.defType};`).join(";\n") +
+                        `\n}\n`;
+                }
+            }).join("\n"));
+    }
+    return node.ts;
+}));
+Crawler_js_1.Crawler.Register((node) => {
+    if (ts.isImportDeclaration(node) && node.importClause) {
+        return true;
+    }
+    return false;
+}, (node) => {
+    let declaration = node;
+    let localPath = declaration.moduleSpecifier.getText().slice(1, -1);
+    let rbfpath = (0, MiscHelpers_js_1.joinPaths)((0, MiscHelpers_js_1.getPathDir)(node.getSourceFile().fileName), localPath)
+        .replace(/\.ts$/, rbfExt);
+    let clause = declaration.importClause;
+    if (clause.name) {
+        // import name from "module"
+        allFileImports.set(clause.name.getText() + "RBF", rbfpath);
+    }
+    else if (clause.namedBindings) {
+        for (let binding of clause.namedBindings.getChildren()) {
+            if (ts.isNamedImports(binding)) {
+                for (let element of binding.elements) {
+                    // import { name as alias } from "module"
+                    if (element.propertyName) {
+                        currentFileAliases.set(element.propertyName.getText() + "RBF", element.name.getText());
+                    }
+                    // import { name } from "module"
+                    allFileImports.set(element.name.getText() + "RBF", rbfpath);
+                }
+            }
+            // import * as name from "module"
+            else if (ts.isNamespaceImport(binding)) {
+                allFileImports.set(binding.name.getText() + "RBF", rbfpath);
+            }
+        }
+    }
+    return node;
+});
+//Remember all classes that are marked as InlineClass or AddressableClass.
+Crawler_js_1.Crawler.Register((node) => {
+    if (ts.isDecorator(node) && (ts.isClassDeclaration(node.parent) || ts.isClassExpression(node.parent))) {
+        let decorator = node;
+        let decoratorName = ts.isCallExpression(decorator.expression) ? decorator.expression.expression.getText() : decorator.expression.getText();
+        if (decoratorName === "InlineClass" || decoratorName === "AddressableClass") {
+            if (ts.isClassDeclaration(node.parent)) {
+                return true;
+            }
+            else if (ts.isClassExpression(node.parent) && "name" in node.parent && node.parent.name) {
+                return true;
+            }
+            else {
+                (0, ASTHelper_js_1.logError)(node, `Decorator @${decoratorName} can only be applied to named classes.`);
+                return false;
+            }
+        }
+        return false;
+    }
+    return false;
+}, (node) => {
+    var _a, _b, _c, _d, _e, _f;
+    let decorator = node;
+    let decoratorName = ts.isCallExpression(decorator.expression) ? decorator.expression.expression.getText() : decorator.expression.getText();
+    let klassNode = node.parent;
+    if (decoratorName === "InlineClass" || decoratorName === "AddressableClass") {
+        let klassName = klassNode.name.text;
+        let klassExtends = (_b = (_a = klassNode.heritageClauses) === null || _a === void 0 ? void 0 : _a.find(hc => hc.token === ts.SyntaxKind.ExtendsKeyword)) !== null && _b !== void 0 ? _b : null;
+        let klassParents = [];
+        if (klassExtends) {
+            try {
+                klassParents = (0, MiscHelpers_js_1.getAllInheritedMixinClassNames)(klassExtends);
+            }
+            catch (e) {
+                console.error(e.message);
+            }
+        }
+        for (let value of klassParents) {
+            let impo = allFileImports.get(resolveAliases(value));
+            if (impo) {
+                //Add parents to imports for rbf file.
+                let arr = (_c = rbfImports.get(impo.slice(0, -3) + rbfExt)) !== null && _c !== void 0 ? _c : [];
+                rbfImports.set(impo.slice(0, -3) + rbfExt, arr);
+                arr.push(resolveAliases(value) + "RBF");
+                //Add parents to imports for def file.
+                arr = (_d = defImports.get(impo.slice(0, -3) + defExt)) !== null && _d !== void 0 ? _d : [];
+                defImports.set(impo.slice(0, -3) + defExt, arr);
+                arr.push(resolveAliases(value) + "Data");
+                arr.push(resolveAliases(value) + "Serialised");
+                arr.push(resolveAliases(value) + "Construct");
+            }
+        }
+        let klassGenerics = (_f = (_e = klassNode.typeParameters) === null || _e === void 0 ? void 0 : _e.map(e => e.name.getText())) !== null && _f !== void 0 ? _f : [];
+        let klassInfo = {
+            Name: klassName,
+            DataName: klassName,
+            Referenced: decoratorName === "AddressableClass",
+            Parents: klassParents,
+            Generics: klassGenerics,
+            PropertyConfig: {},
+            AllPropertyNames: [],
+            OwnPropertyNames: [],
+            TypescriptProperties: [],
+            SerialisedProperties: [],
+            DataProperties: [],
+            ExposedFunctions: []
+        };
+        Klasses.set(klassName, klassInfo);
+        rbfContents.push(klassInfo);
+    }
+    //Don't remove the node - Replicable can use it to determine if there's an RBF to be imported.
+    return node;
+});
+function recursivelyConvertType(typeNode) {
+    if (ts.isUnionTypeNode(typeNode)) {
+        return {
+            OR: typeNode.types.map(t => recursivelyConvertType(t))
+        };
+    }
+    else if (ts.isArrayTypeNode(typeNode)) {
+        return {
+            Is: "Array",
+            Containing: [recursivelyConvertType(typeNode.elementType)]
+        };
+    }
+    else if (ts.isTypeReferenceNode(typeNode)) {
+        if (typeNode.typeArguments && typeNode.typeArguments.length > 0) {
+            return {
+                Is: typeNode.typeName.getText(),
+                Containing: typeNode.typeArguments.map(t => recursivelyConvertType(t))
+            };
+        }
+        return {
+            Is: typeNode.typeName.getText()
+        };
+    }
+    else if (typeNode.kind == ts.SyntaxKind.StringKeyword) {
+        return {
+            Is: "String"
+        };
+    }
+    else if (typeNode.kind == ts.SyntaxKind.NumberKeyword) {
+        return {
+            Is: "Number"
+        };
+    }
+    else if (typeNode.kind == ts.SyntaxKind.BooleanKeyword) {
+        return {
+            Is: "Boolean"
+        };
+    }
+    else if (typeNode.kind === ts.SyntaxKind.AnyKeyword) {
+        return {
+            Is: "Object"
+        };
+    }
+    else if (typeNode.kind === ts.SyntaxKind.VoidKeyword) {
+        return {
+            Is: "Void"
+        };
+    }
+    else if (typeNode.kind === ts.SyntaxKind.NeverKeyword) {
+        return {
+            Is: "Never"
+        };
+    }
+    else if (ts.isLiteralTypeNode(typeNode)) {
+        if (typeNode.literal.kind === ts.SyntaxKind.NullKeyword) {
+            return {
+                Is: "Null"
+            };
+        }
+        else if (typeNode.literal.kind === ts.SyntaxKind.NumberKeyword) {
+            return {
+                Is: "String",
+                RestrictedTo: typeNode.literal.text.includes(".") ?
+                    parseInt(typeNode.literal.text) : parseFloat(typeNode.literal.text),
+            };
+        }
+        else if (typeNode.literal.kind === ts.SyntaxKind.StringKeyword) {
+            return {
+                Is: "String",
+                RestrictedTo: typeNode.literal.text
+            };
+        }
+        else if (typeNode.literal.kind === ts.SyntaxKind.TrueKeyword) {
+            return {
+                Is: "Boolean",
+                RestrictedTo: true
+            };
+        }
+        else if (typeNode.literal.kind === ts.SyntaxKind.FalseKeyword) {
+            return {
+                Is: "Boolean",
+                RestrictedTo: false
+            };
+        }
+    }
+    //Inline JSON.
+    else if (ts.isTypeLiteralNode(typeNode)) {
+        return {
+            Is: "Object"
+        };
+    }
+    (0, ASTHelper_js_1.logError)(typeNode, `Unsupported type value for @Property, @Get or @Function syntax :${ts.SyntaxKind[typeNode.kind]}`);
+    return {
+        Is: "Unknown"
+    };
+}
+// Handle @Property, @Setter and @Getter decorators.
+Crawler_js_1.Crawler.Register((node) => {
+    if (ts.isDecorator(node) && ts.isPropertyDeclaration(node.parent) && ts.isCallExpression(node.expression) && node.expression.expression.getText() === "Property") {
+        return true;
+    }
+    return false;
+}, (node) => {
+    let decorator = node;
+    let propertyNode = node.parent;
+    let klassNode = propertyNode.parent;
+    let klassName = klassNode.name.text;
+    let klassInfo = Klasses.get(klassName);
+    if (!klassInfo) {
+        console.error((0, ASTHelper_js_1.logError)(klassNode, `Class ${klassName} is not marked as @InlineClass or @AddressableClass but has a @Property decorator.`));
+        return [];
+    }
+    let propertyName = propertyNode.name.getText();
+    let dataName = makeDataName(propertyName);
+    let typeChecker = Crawler_js_1.Crawler.GetProgram().ts.getTypeChecker();
+    //Use static type if provided, otherwise dynamic type if initialiser is provided, otherwise unknown.
+    let valueType;
+    if (propertyNode.type) {
+        valueType = propertyNode.type;
+    }
+    else if (propertyNode.initializer) {
+        let newType = typeChecker.typeToTypeNode(typeChecker.getTypeAtLocation(propertyNode.initializer), propertyNode, 0);
+        if (!newType) {
+            (0, ASTHelper_js_1.logError)(propertyNode, `Replicated properties must have a type specified or be initialised to a replicable type.`);
+            newType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+        }
+        valueType = newType;
+    }
+    else {
+        (0, ASTHelper_js_1.logError)(propertyNode, `Replicated properties must have a type specified or be initialised to a replicable type.`);
+        valueType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+    }
+    let dataType = valueType;
+    let configData;
+    if (ts.isCallExpression(decorator.expression) && decorator.expression.arguments.length > 0) {
+        configData = decorator.expression.arguments[0];
+    }
+    if (ts.isCallExpression(decorator.expression) && decorator.expression.typeArguments && decorator.expression.typeArguments.length === 1) {
+        dataType = decorator.expression.typeArguments[0];
+    }
+    function convertTypeToDeclarationFormats(postfix, node) {
+        node = (0, ts_clone_node_1.cloneNode)(node, { factory: Crawler_js_1.Crawler.getContext().factory });
+        function convertIdentifiers(typeNode) {
+            if (ts.isUnionTypeNode(typeNode)) {
+                return ts.visitEachChild(typeNode, convertIdentifiers, Crawler_js_1.Crawler.getContext());
+            }
+            else if (ts.isIdentifier(typeNode)) {
+                return postfix.map((e) => {
+                    var _a;
+                    let impo = allFileImports.get(typeNode.text);
+                    if (impo) {
+                        let arr = (_a = defImports.get(impo)) !== null && _a !== void 0 ? _a : [];
+                        defImports.set(impo.slice(0, -3) + defExt, arr);
+                        arr.push(typeNode.text + e);
+                    }
+                    if (e === "Serialised") {
+                        //Definitely an illegal identifier - maybe it'll work anyway and make it easy for us to use?
+                        return ts.factory.createIdentifier(`["${ts.factory.createIdentifier(typeNode.text + e)}", ${ts.factory.createIdentifier(typeNode.text + e)}]`);
+                    }
+                    return ts.factory.createIdentifier(typeNode.text + e);
+                });
+            }
+            else {
+                if (postfix.includes("Serialised")) {
+                    if (postfix.length > 1) {
+                        return ts.factory.createUnionTypeNode([ts.factory.createTupleTypeNode([ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("Primitive")), typeNode]),
+                            (0, ts_clone_node_1.cloneNode)(typeNode)]);
+                    }
+                    return ts.factory.createTupleTypeNode([ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("Primitive")), typeNode]);
+                }
+                return typeNode;
+            }
+        }
+        let resultType = ts.visitNode(node, convertIdentifiers);
+        let resultString = printNode(resultType, Crawler_js_1.Crawler.GetFile().ts, ts.EmitHint.Unspecified);
+        return resultString.replace(/(?:\n|\t| {4})/g, "");
+    }
+    klassInfo.OwnPropertyNames.push(propertyName);
+    klassInfo.OwnPropertyNames.sort();
+    //Steps:
+    if (configData) {
+        klassInfo.PropertyConfig[propertyName] = configData;
+    }
+    klassInfo.DataProperties.push({
+        propertyName,
+        dataName,
+        // 2. Create type that will go in the RBF File, as the data type.
+        rbfType: recursivelyConvertType(dataType),
+        // 5. Create type that will go in the definition file as the data type.
+        defType: convertTypeToDeclarationFormats(["Data"], dataType),
+    });
+    klassInfo.SerialisedProperties.push({
+        propertyName,
+        // 1. Create type that will go in the RBF File as the typescript type.
+        rbfType: recursivelyConvertType(valueType),
+        // 4. Create type that will go in the definition file as the serialised type.
+        defType: convertTypeToDeclarationFormats(["Serialised"], valueType),
+    });
+    klassInfo.TypescriptProperties.push({
+        propertyName,
+        dataName,
+        // 1. Create type that will go in the RBF File as the typescript type.
+        rbfType: recursivelyConvertType(valueType),
+        // 3. Create type that will go in the definition file as the typescript/construct type.
+        defType: convertTypeToDeclarationFormats(["", "Data", "Serialised"], valueType),
+    });
+    //Remove the decorator.
+    return [];
+});
+// Handle @Function decorators.
+// Handle Migration function calls - which allow specifying custom migration logic for old properties/values.
+//# sourceMappingURL=ReplicableTransformer.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bikky/compiler",
-    "version": "0.0.79",
+    "version": "0.1.1",
     "description": "Typescript modified for compiling space squad",
     "main": "./Libraries/BiscuitLibraries.mjs",
     "type": "commonjs",
@@ -12,14 +12,15 @@
         "bikcserver": "./Execution/bikcserver"
     },
     "dependencies": {
+        "@bikky/path": "^0.0.18",
+        "@bikky/smart-collections": "^0.0.43",
+        "ts-clone-node": "^4.0.0",
         "ts-patch": "^3.1.2",
         "typescript": "5.4.5"
     },
     "devDependencies": {
-        "@bikky/path": "^0.0.18",
         "@types/node": "^18.0.0",
         "@vitest/coverage-istanbul": "^2.0.0-beta.12",
-        "axios": "^1.10.0",
         "vitest": "^2.0.0-beta.12"
     },
     "scripts": {