@bikky/compiler 0.1.17 → 0.2.0

package/Transformers/Main.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("./DelayTransformer.js");
 require("./MixinTransformer.js");
-require("./ReplicableTransformer.js");
+require("./RBFTransformer.js");
 const Crawler_js_1 = require("../Source/ASTInterface/Crawler.js");
 function default_1(program, pluginOptions) {
     Crawler_js_1.Crawler.SetProgram(program);
@@ -10,7 +10,8 @@ function default_1(program, pluginOptions) {
         Crawler_js_1.Crawler.setContext(context);
         return (sourceFile) => {
             Crawler_js_1.Crawler.SetFile(sourceFile);
-            return Crawler_js_1.Crawler.Crawl(sourceFile);
+            let result = Crawler_js_1.Crawler.Crawl(sourceFile);
+            return result;
         };
     };
 }

package/Transformers/RBFHelpers/Constants.d.ts

@@ -0,0 +1,3 @@
+export declare const rbfExt = ".rbf.js";
+export declare const defExt = ".data.d.ts";
+//# sourceMappingURL=Constants.d.ts.map

package/Transformers/RBFHelpers/Constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Constants.d.ts","sourceRoot":"","sources":["Constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,YAAY,CAAC;AAChC,eAAO,MAAM,MAAM,eAAe,CAAC"}

package/Transformers/RBFHelpers/Constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defExt = exports.rbfExt = void 0;
+//RBF = Replication Breakdown File.
+exports.rbfExt = ".rbf.js";
+exports.defExt = ".data.d.ts";
+//# sourceMappingURL=Constants.js.map

package/Transformers/RBFHelpers/Imports.d.ts

@@ -0,0 +1,12 @@
+import * as ts from "../../Cache/typescript.js";
+export declare namespace Imports {
+    function getRBFImports(): string;
+    function getDefImports(): string;
+    function resolveAliases(name: string): string;
+    function requestValueImport(value: string | ts.Identifier | ts.QualifiedName | ts.PropertyAccessExpression, locations: ("RBF" | "Data")[]): boolean;
+    /**
+     * Imports a class or the appropriate class's declaration.
+     */
+    function requestClassImport(value: string | ts.Identifier | ts.QualifiedName, postfixes: string[]): boolean;
+}
+//# sourceMappingURL=Imports.d.ts.map

package/Transformers/RBFHelpers/Imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Imports.d.ts","sourceRoot":"","sources":["Imports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAMhD,yBAAc,OAAO,CAAC;IAQrB,SAAgB,aAAa,WAO5B;IAED,SAAgB,aAAa,WAM5B;IAUD,SAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKnD;IA4BD,SAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,wBAAwB,EAAE,SAAS,EAAE,CAAC,KAAK,GAAG,MAAM,CAAC,EAAE,GAAG,OAAO,CAAC;IAkC3J;;OAEG;IACH,SAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,aAAa,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;CA0GnH"}

package/Transformers/RBFHelpers/Imports.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Imports = void 0;
+const ts = require("../../Cache/typescript.js");
+const Crawler_js_1 = require("../../Source/ASTInterface/Crawler.js");
+const ASTHelper_js_1 = require("../../Source/ASTHelper.js");
+const Constants_js_1 = require("./Constants.js");
+var Imports;
+(function (Imports) {
+    let allFileImports = new Map();
+    let currentFileAliases = new Map();
+    let rbfImports = new Map();
+    let rbfAliases = [];
+    let defImports = new Map();
+    let defAliases = [];
+    function getRBFImports() {
+        return Array.from(rbfImports.entries()).map(([key, value]) => {
+            value = Array.from(new Set(value));
+            return `import { ${value.join(", ")} } from "${key}";`;
+        }).join("\n") + "\n"
+            + `import { RegisterClassRBF } from "@bikky/compiler";\n`
+            + rbfAliases.join("\n");
+    }
+    Imports.getRBFImports = getRBFImports;
+    function getDefImports() {
+        return Array.from(defImports.entries()).map(([key, value]) => {
+            value = Array.from(new Set(value));
+            return `import { ${value.join(", ")} } from "${key}";`;
+        }).join("\n") + "\n"
+            + defAliases.join("\n");
+    }
+    Imports.getDefImports = getDefImports;
+    function replaceExtension(path, ext) {
+        let result = path.replace(/\.js$/, ext);
+        if (result === path) {
+            result = path + ext;
+        }
+        return result;
+    }
+    function resolveAliases(name) {
+        while (currentFileAliases.has(name)) {
+            name = currentFileAliases.get(name);
+        }
+        return name;
+    }
+    Imports.resolveAliases = resolveAliases;
+    function getQualifierBase(name) {
+        if (typeof name === "string") {
+            return name;
+        }
+        while (ts.isPropertyAccessExpression(name)) {
+            let expr = name.expression;
+            if (ts.isIdentifier(expr)) {
+                name = expr;
+                break;
+            }
+            if (!ts.isIdentifier(expr) && !ts.isPropertyAccessExpression(expr)) {
+                (0, ASTHelper_js_1.logError)(name, `Left-most value of property is not an identifier, abandoning attempt to import.`);
+                return null;
+            }
+            name = expr;
+        }
+        while (ts.isQualifiedName(name)) {
+            name = name.left;
+            if (!ts.isIdentifier(name) && !ts.isQualifiedName(name)) {
+                (0, ASTHelper_js_1.logError)(name, `Left-most value in a reference type is not an identifier, abandoning attempt to import.`);
+                return null;
+            }
+        }
+        return name.text;
+    }
+    function requestValueImport(value, locations) {
+        var _a, _b;
+        value = getQualifierBase(value);
+        if (value === null) {
+            //Don't import items that aren't identifiers.
+            return false;
+        }
+        let sourceAlias = resolveAliases(value);
+        let impo = allFileImports.get(sourceAlias);
+        if (!impo) {
+            return false;
+        }
+        if (locations.length === 0) {
+            return false;
+        }
+        if (locations.includes("RBF")) {
+            let arr = (_a = rbfImports.get(impo)) !== null && _a !== void 0 ? _a : [];
+            rbfImports.set(impo, arr);
+            arr.push(value);
+            if (sourceAlias != value) {
+                rbfAliases.push(`import ${value} = ${sourceAlias};`);
+            }
+        }
+        if (locations.includes("Data")) {
+            let arr = (_b = defImports.get(impo)) !== null && _b !== void 0 ? _b : [];
+            defImports.set(impo, arr);
+            arr.push(value);
+            if (sourceAlias != value) {
+                defAliases.push(`import ${value} = ${sourceAlias};`);
+            }
+        }
+        return true;
+    }
+    Imports.requestValueImport = requestValueImport;
+    function requestClassImport(value, postfixes) {
+        var _a, _b, _c;
+        value = getQualifierBase(value);
+        if (value === null) {
+            //Don't import items that aren't identifiers.
+            return false;
+        }
+        let sourceAlias = resolveAliases(value);
+        let impo = allFileImports.get(sourceAlias);
+        if (!impo) {
+            return false;
+        }
+        // Handle the RBF additions.
+        if (postfixes.includes("RBF")) {
+            let rbf = replaceExtension(impo, Constants_js_1.rbfExt);
+            let arr = (_a = rbfImports.get(rbf)) !== null && _a !== void 0 ? _a : [];
+            rbfImports.set(rbf, arr);
+            for (let postfix of postfixes) {
+                if (postfix !== "RBF")
+                    continue;
+                arr.push(value + postfix);
+                if (sourceAlias != value) {
+                    rbfAliases.push(`import ${value}${postfix} = ${sourceAlias}${postfix};`);
+                }
+            }
+            if (postfixes.length === 1) {
+                return true;
+            }
+        }
+        if (postfixes.includes("")) {
+            let arr = (_b = defImports.get(impo)) !== null && _b !== void 0 ? _b : [];
+            defImports.set(impo, arr);
+            arr.push(value);
+            if (sourceAlias != value) {
+                defAliases.push(`import ${value} = ${sourceAlias};`);
+            }
+        }
+        //Handle the Data file additions.
+        let def = replaceExtension(impo, Constants_js_1.defExt);
+        let arr = (_c = defImports.get(def)) !== null && _c !== void 0 ? _c : [];
+        defImports.set(def, arr);
+        for (let postfix of postfixes) {
+            if (postfix === "RBF" || postfix === "") {
+                continue;
+            }
+            arr.push(value + postfix);
+            if (sourceAlias != value) {
+                defAliases.push(`import ${value}${postfix} = ${sourceAlias}${postfix};`);
+            }
+        }
+        return true;
+    }
+    Imports.requestClassImport = requestClassImport;
+    function resetImports() {
+        allFileImports.clear();
+        currentFileAliases.clear();
+        rbfImports.clear();
+        defImports.clear();
+        rbfAliases = [];
+        defAliases = [];
+    }
+    Crawler_js_1.Crawler.OnFile((node) => {
+        resetImports();
+    });
+    /**
+     * For any import statement in the .ts file, we record it so that we can create an equivalent
+     * import in a .d.ts or .rbf.js file later.
+     */
+    Crawler_js_1.Crawler.Register((node) => {
+        return !!(ts.isImportDeclaration(node) && node.importClause);
+    }, (node) => {
+        let declaration = node;
+        let localPath = declaration.moduleSpecifier.getText().slice(1, -1);
+        // let rbfpath = joinPaths(getPathDir(node.getSourceFile().fileName), localPath)
+        // 	.replace(/\.ts$/, rbfExt);
+        let rbfpath = localPath.replace(/\.js$/, Constants_js_1.rbfExt);
+        // let defpath = localPath.replace(/\.js$/, defExt);
+        let clause = declaration.importClause;
+        if (clause.name) {
+            // import name from "module"
+            allFileImports.set(clause.name.getText() + "RBF", rbfpath);
+            allFileImports.set(clause.name.getText(), localPath);
+        }
+        else if (clause.namedBindings) {
+            if ("elements" in clause.namedBindings) {
+                for (let binding of clause.namedBindings.elements) {
+                    // import { name as alias } from "module"
+                    // import { name } from "module"
+                    if (ts.isImportSpecifier(binding)) {
+                        if (binding.propertyName) {
+                            currentFileAliases.set(binding.propertyName.getText(), binding.name.getText());
+                        }
+                        allFileImports.set(binding.name.getText() + "RBF", rbfpath);
+                        allFileImports.set(binding.name.getText(), localPath);
+                    }
+                }
+            }
+            else {
+                // import * as name from "module"
+                allFileImports.set(clause.namedBindings.name.getText() + "RBF", rbfpath);
+                allFileImports.set(clause.namedBindings.name.getText(), localPath);
+            }
+        }
+        return node;
+    });
+})(Imports || (exports.Imports = Imports = {}));
+//# sourceMappingURL=Imports.js.map

package/Transformers/RBFHelpers/Print.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=Print.d.ts.map

package/Transformers/RBFHelpers/Print.d.ts.map

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

package/Transformers/RBFHelpers/Print.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=Print.js.map

package/Transformers/RBFHelpers/PropertyConfig.d.ts

@@ -0,0 +1,65 @@
+import * as ts from "../../Cache/typescript.js";
+import { RBFTypes } from "../../Libraries/RBFTypes.js";
+export declare namespace PropertyConfig {
+    const primitiveReaders: {
+        String: {
+            tryReadLiteral: (node: ts.Node) => string | null;
+        };
+        Boolean: {
+            tryReadLiteral(node: ts.Node): boolean | null;
+        };
+        Number: {
+            tryReadLiteral(node: ts.Node): number | null;
+        };
+    };
+    function extractConfigData(arg: ts.ObjectLiteralExpression, optional: boolean): RBFTypes.PropertyConfiguration;
+}
+export declare namespace MakeRBFTypes {
+    /**
+     * Reads primitive's data and converts it into usable formats.
+     */
+    interface PrimitiveReader {
+        /**
+         * Whether or not multiple entries of this thing should be grouped,
+         * for example string and number literals.
+         */
+        shouldGroup: boolean;
+        /**
+         * The name on the left-hand side when serialising the type.
+         */
+        serialisedName: string;
+        /**
+         * True if the node is one of these, false if not. Alternatively can
+         * return an options object which contains
+         *  @param valid: whether the node is or is not of this type.
+         *  @param values: if this node has a limited number of possible values.
+         *  @param containTypes: if this node has specific generic types for it's properties.
+         */
+        isThisType: (node: ts.TypeNode) => boolean | {
+            valid: boolean;
+            values?: any[];
+            containsTypes?: ts.TypeNode[];
+        };
+        /**
+         * If this node has a custom load format, do that here.
+         */
+        makeDataNodes?: (node: ts.TypeNode) => ts.TypeNode[];
+        /**
+         * If this node has a custom serialise format, do that here.
+         */
+        makeSerialisedNodes?: (node: ts.TypeNode) => ts.TypeNode[];
+        tryReadLiteral?: (node: ts.Node) => string | number | boolean | null;
+    }
+    const primitiveReaders: {
+        [typeName: string]: PrimitiveReader;
+    };
+    function recurseBasicType(child: ts.TypeNode, childrenTypes: {
+        [name: string]: {
+            values?: (string | number | boolean)[];
+            subTypes?: RBFTypes.RecursivePropertyType[];
+        };
+    }): void;
+    function recursivelyConvertType(typeNode: ts.TypeNode): RBFTypes.RecursivePropertyType;
+}
+export declare function convertTypeToDeclarationFormats(postfixes: string[], node: ts.TypeNode): string;
+//# sourceMappingURL=PropertyConfig.d.ts.map

package/Transformers/RBFHelpers/PropertyConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PropertyConfig.d.ts","sourceRoot":"","sources":["PropertyConfig.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAQvD,yBAAc,cAAc,CAAC;IAGrB,MAAM,gBAAgB;;mCAEJ,OAAO;;;iCAKT,OAAO;;;iCAKP,OAAO;;KAK7B,CAAA;IAGD,SAAgB,iBAAiB,CAAC,GAAG,EAAE,EAAE,CAAC,uBAAuB,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,CAAC,qBAAqB,CAsDpH;CACD;AAGD,yBAAc,YAAY,CAAC;IAI1B;;OAEG;IACH,UAAiB,eAAe;QAC/B;;;WAGG;QACH,WAAW,EAAE,OAAO,CAAC;QACrB;;WAEG;QACH,cAAc,EAAE,MAAM,CAAC;QACvB;;;;;;WAMG;QACH,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,KAAK,OAAO,GAAG;YAAE,KAAK,EAAE,OAAO,CAAC;YAAC,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC;YAAC,aAAa,CAAC,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAA;SAAE,CAAC;QAC/G;;WAEG;QACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,KAAK,EAAE,CAAC,QAAQ,EAAE,CAAC;QACrD;;WAEG;QACH,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,KAAK,EAAE,CAAC,QAAQ,EAAE,CAAC;QAC3D,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;KACrE;IAEM,MAAM,gBAAgB,EAAE;QAC9B,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,CAAC;KAyHpC,CAAA;IAED,SAAgB,gBAAgB,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,EAAE,aAAa,EAAE;QACnE,CAAC,IAAI,EAAE,MAAM,GAAG;YAAE,MAAM,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;YAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,qBAAqB,EAAE,CAAA;SAAE,CAAA;KACvG,QAkCA;IAED,SAAgB,sBAAsB,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,GAAG,QAAQ,CAAC,qBAAqB,CAuC5F;CAED;AAiBD,wBAAgB,+BAA+B,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,QAAQ,UAqHrF"}