@bikky/compiler 0.1.18 → 0.2.1

package/Transformers/RBFHelpers/PropertyConfig.js

@@ -0,0 +1,420 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertTypeToDeclarationFormats = exports.MakeRBFTypes = exports.PropertyConfig = void 0;
+/// <reference type="../../Libraries/GlobalTypes.d.ts">
+const ts = require("../../Cache/typescript.js");
+const ASTHelper_js_1 = require("../../Source/ASTHelper.js");
+const Crawler_js_1 = require("../../Source/ASTInterface/Crawler.js");
+const Imports_js_1 = require("./Imports.js");
+const ts_clone_node_1 = require("ts-clone-node");
+var printNode = ASTHelper_js_1.Printer.printNode;
+var PropertyConfig;
+(function (PropertyConfig) {
+    var printNode = ASTHelper_js_1.Printer.printNode;
+    PropertyConfig.primitiveReaders = {
+        String: {
+            tryReadLiteral: (node) => {
+                return ts.isStringLiteral(node) ? node.text : null;
+            }
+        },
+        Boolean: {
+            tryReadLiteral(node) {
+                return node.kind === ts.SyntaxKind.TrueKeyword ? true : node.kind === ts.SyntaxKind.FalseKeyword ? false : null;
+            }
+        },
+        Number: {
+            tryReadLiteral(node) {
+                return ts.isNumericLiteral(node) ? (node.text.includes(".") ?
+                    parseInt(node.text) : parseFloat(node.text)) : null;
+            }
+        }
+    };
+    function extractConfigData(arg, optional) {
+        let result = {}; //RBFTypes.PropertyConfiguration
+        //iterate each property.
+        for (let pa of arg.properties) {
+            if (!ts.isPropertyAssignment(pa)) {
+                (0, ASTHelper_js_1.logError)(pa, `@Property preprocessor command only accepts literal property assignments.`);
+                continue;
+            }
+            let name = pa.name.getText();
+            switch (name) {
+                case "computed": {
+                    let value = PropertyConfig.primitiveReaders.Boolean.tryReadLiteral(pa.initializer);
+                    if (value === null) {
+                        value = PropertyConfig.primitiveReaders.String.tryReadLiteral(pa.initializer);
+                    }
+                    if (value === null || (typeof value === "string" && value !== "manualLoad")) {
+                        (0, ASTHelper_js_1.logError)(pa, `@Property's ${name} value can only be "manualLoad" or boolean literal.`);
+                        continue;
+                    }
+                    result[name] = value;
+                    continue;
+                }
+                case "dataName": {
+                    let value = PropertyConfig.primitiveReaders.String.tryReadLiteral(pa.initializer);
+                    if (value === null) {
+                        (0, ASTHelper_js_1.logError)(pa, `@Property's ${name} value must be a string.`);
+                        continue;
+                    }
+                    result[name] = value;
+                    continue;
+                }
+                case "customLoad":
+                case "readonly":
+                case "manualRestore":
+                case "expression":
+                case "setter":
+                case "inline":
+                case "optional":
+                case "id": {
+                    let value = PropertyConfig.primitiveReaders.Boolean.tryReadLiteral(pa.initializer);
+                    if (value === null) {
+                        (0, ASTHelper_js_1.logError)(pa, `@Property's ${name} value must be a boolean.`);
+                        continue;
+                    }
+                    result[name] = value;
+                    continue;
+                }
+                case "default": {
+                    result[name] = printNode(pa, Crawler_js_1.Crawler.GetFile().ts, ts.EmitHint.Unspecified);
+                    continue;
+                }
+            }
+            (0, ASTHelper_js_1.logError)(pa, `Invalid value for @Property configuration, ${name}`);
+        }
+        if (!("optional" in result)) {
+            result.optional = optional;
+        }
+        return result;
+    }
+    PropertyConfig.extractConfigData = extractConfigData;
+})(PropertyConfig || (exports.PropertyConfig = PropertyConfig = {}));
+var MakeRBFTypes;
+(function (MakeRBFTypes) {
+    MakeRBFTypes.primitiveReaders = {
+        Array: {
+            shouldGroup: false,
+            serialisedName: "Array",
+            isThisType: (node) => {
+                if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.text === "Array") {
+                    return {
+                        valid: true,
+                        containsTypes: [...node.typeArguments]
+                    };
+                }
+                if (!ts.isArrayTypeNode(node))
+                    return false;
+                return {
+                    valid: true,
+                    containsTypes: [node.elementType],
+                };
+            },
+        },
+        Dict: {
+            shouldGroup: false,
+            serialisedName: "Dict",
+            //{[index: first]: second}
+            isThisType: (node) => {
+                if (ts.isTypeLiteralNode(node) && node.members.length === 1 && node.members[0].kind == ts.SyntaxKind.IndexSignature) {
+                    let signature = node.members[0];
+                    return {
+                        valid: true,
+                        containsTypes: [signature.parameters[0].type, signature.type]
+                    };
+                }
+                return false;
+            }
+        },
+        Map: {
+            shouldGroup: false,
+            serialisedName: "Map",
+            isThisType: (node) => {
+                if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.text === "Map") {
+                    return {
+                        valid: true,
+                        containsTypes: [...node.typeArguments]
+                    };
+                }
+                return false;
+            }
+        },
+        String: {
+            shouldGroup: true,
+            serialisedName: "Primitive",
+            isThisType: (node) => {
+                if (node.kind === ts.SyntaxKind.StringKeyword) {
+                    return true;
+                }
+                if (ts.isLiteralTypeNode(node) && node.literal.kind === ts.SyntaxKind.StringLiteral) {
+                    return {
+                        valid: true,
+                        values: [node.literal.text]
+                    };
+                }
+                return false;
+            },
+            tryReadLiteral: (node) => {
+                return ts.isStringLiteral(node) ? node.text : null;
+            }
+        },
+        Boolean: {
+            shouldGroup: true,
+            serialisedName: "Primitive",
+            isThisType: (node) => {
+                if (node.kind == ts.SyntaxKind.BooleanKeyword) {
+                    return true;
+                }
+                else if (ts.isLiteralTypeNode(node)) {
+                    if (node.literal.kind === ts.SyntaxKind.TrueKeyword) {
+                        return {
+                            valid: true,
+                            values: [true]
+                        };
+                    }
+                    else if (node.literal.kind === ts.SyntaxKind.FalseKeyword) {
+                        return {
+                            valid: true,
+                            values: [false]
+                        };
+                    }
+                }
+                return false;
+            },
+            tryReadLiteral(node) {
+                return node.kind === ts.SyntaxKind.TrueKeyword ? true : node.kind === ts.SyntaxKind.FalseKeyword ? false : null;
+            }
+        },
+        Number: {
+            shouldGroup: true,
+            serialisedName: "Primitive",
+            isThisType: (node) => {
+                if (node.kind === ts.SyntaxKind.NumberKeyword) {
+                    return true;
+                }
+                if (ts.isLiteralTypeNode(node) && node.literal.kind === ts.SyntaxKind.NumericLiteral) {
+                    return {
+                        valid: true,
+                        values: [node.literal.text.includes(".") ?
+                                parseInt(node.literal.text) : parseFloat(node.literal.text),]
+                    };
+                }
+                return false;
+            },
+            tryReadLiteral(node) {
+                return ts.isNumericLiteral(node) ? (node.text.includes(".") ?
+                    parseInt(node.text) : parseFloat(node.text)) : null;
+            }
+        },
+        Object: {
+            shouldGroup: false,
+            serialisedName: "Object",
+            isThisType: (node) => {
+                return ts.isTypeLiteralNode(node) || node.kind === ts.SyntaxKind.AnyKeyword;
+            }
+        }
+    };
+    function recurseBasicType(child, childrenTypes) {
+        for (let readerName of Object.getOwnPropertyNames(MakeRBFTypes.primitiveReaders)) {
+            let reader = MakeRBFTypes.primitiveReaders[readerName];
+            let result = reader.isThisType(child);
+            if (result === false)
+                continue;
+            if (result === true) {
+                //Empty!
+                childrenTypes[readerName] = {};
+                return;
+            }
+            if (!result.valid)
+                continue;
+            if (!childrenTypes[readerName]) {
+                childrenTypes[readerName] = {};
+            }
+            if (result.values) {
+                if (!childrenTypes[readerName].values) {
+                    childrenTypes[readerName].values = [];
+                }
+                childrenTypes[readerName].values.push(...result.values);
+            }
+            if (result.containsTypes) {
+                if (!childrenTypes[readerName].subTypes) {
+                    childrenTypes[readerName].subTypes = [];
+                }
+                childrenTypes[readerName].subTypes.push(...result.containsTypes.map((e) => recursivelyConvertType(e)));
+            }
+            return;
+        }
+        if (ts.isTypeReferenceNode(child) && ts.isIdentifier(child.typeName)) {
+            childrenTypes[child.typeName.text] = {};
+            return;
+        }
+        (0, ASTHelper_js_1.logError)(child, `Unsupported type value for @Property, @Get or @Function syntax :${ts.SyntaxKind[child.kind]}`);
+        childrenTypes["Unknown"] = {};
+    }
+    MakeRBFTypes.recurseBasicType = recurseBasicType;
+    function recursivelyConvertType(typeNode) {
+        if (ts.isUnionTypeNode(typeNode)) {
+            let childrenTypes = {};
+            loopUnionContents: for (let child of typeNode.types) {
+                recurseBasicType(child, childrenTypes);
+            }
+            let names = Object.getOwnPropertyNames(childrenTypes);
+            if (names.length === 1) {
+                let name = names[0];
+                let type = childrenTypes[name];
+                return {
+                    Is: name,
+                    RestrictedTo: type.values,
+                    Containing: type.subTypes,
+                };
+                ;
+            }
+            return {
+                OR: Object.getOwnPropertyNames(childrenTypes).map((name) => {
+                    return {
+                        Is: name,
+                        RestrictedTo: childrenTypes[name].values,
+                        Containing: childrenTypes[name].subTypes,
+                    };
+                })
+            };
+        }
+        let childrenTypes = {};
+        recurseBasicType(typeNode, childrenTypes);
+        let name = Object.getOwnPropertyNames(childrenTypes)[0];
+        let type = childrenTypes[name];
+        return {
+            Is: name,
+            RestrictedTo: type.values,
+            Containing: type.subTypes,
+        };
+    }
+    MakeRBFTypes.recursivelyConvertType = recursivelyConvertType;
+})(MakeRBFTypes || (exports.MakeRBFTypes = MakeRBFTypes = {}));
+const PlainTypes = [
+    ts.SyntaxKind.AnyKeyword,
+    ts.SyntaxKind.UnknownKeyword,
+    ts.SyntaxKind.StringKeyword,
+    ts.SyntaxKind.NumberKeyword,
+    ts.SyntaxKind.BigIntKeyword,
+    ts.SyntaxKind.BooleanKeyword,
+    ts.SyntaxKind.SymbolKeyword,
+    ts.SyntaxKind.VoidKeyword,
+    ts.SyntaxKind.UndefinedKeyword,
+    ts.SyntaxKind.NullKeyword,
+    ts.SyntaxKind.ThisKeyword,
+    ts.SyntaxKind.NeverKeyword,
+];
+function convertTypeToDeclarationFormats(postfixes, node) {
+    node = (0, ts_clone_node_1.cloneNode)(node, { factory: Crawler_js_1.Crawler.getContext().factory });
+    /**
+     * Update the provided type reference's identifiers to use the provided postfixes.
+     */
+    function importAndConvertIdentifiers(typeNode, typeArgs) {
+        let className = ts.isQualifiedName(typeNode.typeName) ? typeNode.typeName.right.text : typeNode.typeName.text;
+        //Handle edge-cases for built-in types. We don't map them to serialised classes we treat them as primitives.
+        if (ts.isIdentifier(typeNode.typeName) && (className === "Array" || className === "Map" || className === "Set")) {
+            let results = [ts.factory.updateTypeReferenceNode(typeNode, typeNode.typeName, typeArgs)];
+            if (postfixes.includes("SerialisedReference")) {
+                let serialised = ts.factory.createTupleTypeNode([
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(className)),
+                    ts.factory.updateTypeReferenceNode(typeNode, typeNode.typeName, typeArgs)
+                ]);
+                if (postfixes.length > 1) {
+                    results.push(serialised);
+                }
+                else {
+                    results[0] = serialised;
+                }
+            }
+            if (results.length === 1)
+                return results[0];
+            return ts.factory.createUnionTypeNode(results);
+        }
+        //Add necessary imports to file.
+        Imports_js_1.Imports.requestClassImport(typeNode.typeName, postfixes);
+        let results = [];
+        for (let postfix of postfixes) {
+            let renamedNode = (0, ts_clone_node_1.cloneNode)(typeNode.typeName);
+            //Update the name.
+            {
+                let newNameNode = ts.factory.createIdentifier(className + postfix);
+                if (ts.isQualifiedName(renamedNode)) {
+                    ts.factory.updateQualifiedName(renamedNode, renamedNode.left, newNameNode);
+                }
+                else {
+                    renamedNode = newNameNode;
+                }
+            }
+            let finalType = ts.factory.createTypeReferenceNode(renamedNode, typeArgs ? ts.factory.createNodeArray(typeArgs.map((e) => (0, ts_clone_node_1.cloneNode)(e))) : undefined);
+            results.push(finalType);
+        }
+        if (results.length === 1)
+            return results[0];
+        return ts.factory.createUnionTypeNode(results);
+    }
+    /**
+     * Recursively search through the typing nodes and convert any discovered identifiers to have
+     * the supplied postfixes.
+     */
+    function findIdentifiers(typeNode) {
+        var _a;
+        //TODO: Throw a hissy fit if the `this` type keyword is used - or just replace it with whatever the current
+        // class is.
+        if (ts.isUnionTypeNode(typeNode)) {
+            return ts.visitEachChild(typeNode, findIdentifiers, Crawler_js_1.Crawler.getContext());
+        }
+        else if (ts.isArrayTypeNode(typeNode)) {
+            typeNode = ts.factory.updateArrayTypeNode(typeNode, ts.visitNode(typeNode.elementType, findIdentifiers));
+            if (postfixes.includes("SerialisedReference")) {
+                if (postfixes.length > 1) {
+                    return ts.factory.createUnionTypeNode([ts.factory.createTupleTypeNode([ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("Array")), typeNode]),
+                        (0, ts_clone_node_1.cloneNode)(typeNode)]);
+                }
+                return ts.factory.createTupleTypeNode([ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("Array")), typeNode]);
+            }
+            return typeNode;
+        }
+        //Handle {[name: string]: MyThing}
+        else if (ts.isTypeLiteralNode(typeNode) && typeNode.members.length === 1 && ts.isIndexSignatureDeclaration(typeNode.members[0])) {
+            //Change MyThing to MyThingSerialisedReference or MyThingData or whatever's good.
+            typeNode = ts.factory.updateTypeLiteralNode(typeNode, ts.factory.createNodeArray(typeNode.members.map((e) => {
+                let decl = e;
+                return ts.factory.updateIndexSignature(decl, decl.modifiers, decl.parameters, ts.visitNode(decl.type, findIdentifiers));
+            })));
+            //If this is serialised we need to make it ["Dict", {[name: string]: MyThing}] (and union it if we're
+            // trying for more than one type.
+            if (postfixes.includes("SerialisedReference")) {
+                if (postfixes.length > 1) {
+                    return ts.factory.createUnionTypeNode([ts.factory.createTupleTypeNode([ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("Dict")), typeNode]),
+                        (0, ts_clone_node_1.cloneNode)(typeNode)]);
+                }
+                return ts.factory.createTupleTypeNode([ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("Dict")), typeNode]);
+            }
+            // return the result!
+            return typeNode;
+        }
+        else if (ts.isTypeReferenceNode(typeNode)) {
+            let typeArgs = (_a = typeNode.typeArguments) === null || _a === void 0 ? void 0 : _a.map((e) => {
+                return (PlainTypes.includes(e.kind) || ts.isTypeLiteralNode(e)) ? e : ts.visitNode(e, findIdentifiers);
+            });
+            let result = importAndConvertIdentifiers(typeNode, typeArgs ? ts.factory.createNodeArray(typeArgs) : undefined);
+            return result;
+        }
+        else {
+            if (postfixes.includes("SerialisedReference")) {
+                if (postfixes.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, findIdentifiers);
+    let resultString = printNode(resultType, Crawler_js_1.Crawler.GetFile().ts, ts.EmitHint.Unspecified);
+    return resultString.replace(/(?:\n|\t| {4})/g, "");
+}
+exports.convertTypeToDeclarationFormats = convertTypeToDeclarationFormats;
+//# sourceMappingURL=PropertyConfig.js.map

package/Transformers/RBFTransformer.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RBFTransformer.d.ts.map

package/Transformers/RBFTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RBFTransformer.d.ts","sourceRoot":"","sources":["RBFTransformer.ts"],"names":[],"mappings":""}