@oak-digital/types-4-strapi-2 0.1.1 → 0.1.2

package/lib/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var commander_1 = require("commander");
+var InterfaceManager_1 = __importDefault(require("./interface/InterfaceManager"));
+commander_1.program
+    .name("t4s");
+commander_1.program
+    .option('-i, --in <dir>', 'The src directory for strapi', './src')
+    .option('-o, --out <dir>', 'The output directory to output the types to', './types');
+commander_1.program.parse();
+var options = commander_1.program.opts();
+var input = options.in, out = options.out;
+var manager = new InterfaceManager_1.default(out, input);
+manager.run().catch(function (err) {
+    console.error(err);
+});

package/lib/interface/Attributes.d.ts

@@ -0,0 +1,11 @@
+import Interface from "./Interface";
+export default class Attributes {
+    Attrs: Record<string, Record<string, any>>;
+    private RelationNames;
+    constructor(attr: Record<string, Record<string, any>>, relationNames: Record<string, [string, Interface]>);
+    isAttributeOptional(attr: any): boolean;
+    getDependencies(strapiName: string): any[];
+    attributeToString(attrName: string, attr: any): string;
+    toFieldsString(): string;
+    toString(): string;
+}

package/{src/interface/Attributes.ts → lib/interface/Attributes.js}

@@ -1,15 +1,12 @@
-import Interface from "./Interface";
-
-export default class Attributes {
-    Attrs: Record<string, Record<string, any>>;
-    private RelationNames: Record<string, [string, Interface]> = {};
-
-    constructor(attr: Record<string, Record<string, any>>, relationNames: Record<string, [string, Interface]>) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Attributes = /** @class */ (function () {
+    function Attributes(attr, relationNames) {
+        this.RelationNames = {};
         this.Attrs = attr;
         this.RelationNames = relationNames;
     }
-
-    isAttributeOptional(attr: any) {
+    Attributes.prototype.isAttributeOptional = function (attr) {
         // If it is a component / relation / dynamiczone it is always optional due to population
         switch (attr.type) {
             case "component":
@@ -19,15 +16,13 @@ export default class Attributes {
             default:
                 break;
         }
-
         return false;
-    }
-
-    getDependencies(strapiName: string) {
-        const dependencies = [];
-        for (const attrName in this.Attrs) {
-            const attr = this.Attrs[attrName];
-            let dependencyName : string;
+    };
+    Attributes.prototype.getDependencies = function (strapiName) {
+        var dependencies = [];
+        for (var attrName in this.Attrs) {
+            var attr = this.Attrs[attrName];
+            var dependencyName = void 0;
             switch (attr.type) {
                 case "relation":
                     dependencyName = attr.target;
@@ -45,34 +40,34 @@ export default class Attributes {
             dependencies.push(dependencyName);
         }
         return dependencies;
-    }
-
-    attributeToString(attrName: string, attr: any) {
-        let optionalString = this.isAttributeOptional(attr) ? '?' : '';
-        let str = `    ${attrName}${optionalString}: `
-        let isArray : boolean = false;
+    };
+    Attributes.prototype.attributeToString = function (attrName, attr) {
+        var _a;
+        var optionalString = this.isAttributeOptional(attr) ? '?' : '';
+        var str = "    ".concat(attrName).concat(optionalString, ": ");
+        var isArray = false;
         switch (attr.type) {
             case "relation":
-                const apiName = attr.target;
+                var apiName = attr.target;
                 // console.log(attrName)
                 // console.log(this.RelationNames, apiName)
-                const dependencyName = this.RelationNames[apiName][0];
+                var dependencyName = this.RelationNames[apiName][0];
                 isArray = attr.relation.endsWith("ToMany");
                 str += dependencyName;
                 break;
             case "component":
-                const componentName = attr.component;
-                const dependencyComponentName = this.RelationNames[componentName][0];
-                isArray = attr.repeatable ?? false;
+                var componentName = attr.component;
+                var dependencyComponentName = this.RelationNames[componentName][0];
+                isArray = (_a = attr.repeatable) !== null && _a !== void 0 ? _a : false;
                 str += dependencyComponentName;
                 break;
             case "password":
                 return null;
             case "enumeration":
-                const hasDefault = "default" in attr;
-                const enums = attr.enum.map((en: string) => `"${en}"`)
-                enums.push("null")
-                const typeString = enums.join(" | ");
+                var hasDefault = "default" in attr;
+                var enums = attr.enum.map(function (en) { return "\"".concat(en, "\""); });
+                enums.push("null");
+                var typeString = enums.join(" | ");
                 str += typeString;
                 break;
             case "string":
@@ -101,28 +96,28 @@ export default class Attributes {
                 str += "any";
                 break;
         }
-        const isArrayString = isArray ? '[]' : ''
-        str += `${isArrayString};`;
+        var isArrayString = isArray ? '[]' : '';
+        str += "".concat(isArrayString, ";");
         return str;
-    }
-
-    toFieldsString() : string {
-        const strings = [];
-        for (const attrName in this.Attrs) {
-            const attr = this.Attrs[attrName];
-            const attrString = this.attributeToString(attrName, attr);
+    };
+    Attributes.prototype.toFieldsString = function () {
+        var strings = [];
+        for (var attrName in this.Attrs) {
+            var attr = this.Attrs[attrName];
+            var attrString = this.attributeToString(attrName, attr);
             if (attrString === null) {
                 continue;
             }
-            strings.push(attrString)
+            strings.push(attrString);
         }
-        return strings.map(s => `${s}\n`).join("");
-    }
-
-    toString() : string {
-        const strings = [ "{" ];
+        return strings.map(function (s) { return "".concat(s, "\n"); }).join("");
+    };
+    Attributes.prototype.toString = function () {
+        var strings = ["{"];
         strings.push(this.toFieldsString());
-        strings.push("}")
+        strings.push("}");
         return strings.join("\n");
-    }
-}
+    };
+    return Attributes;
+}());
+exports.default = Attributes;

package/lib/interface/ComponentInterface.d.ts

@@ -0,0 +1,7 @@
+import Interface from "./Interface";
+export default class ComponentInterface extends Interface {
+    protected Category: string;
+    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, category: string, prefix?: string);
+    updateStrapiName(): void;
+    getInterfaceFieldsString(): string;
+}

package/lib/interface/ComponentInterface.js

@@ -0,0 +1,47 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Interface_1 = __importDefault(require("./Interface"));
+var ComponentInterface = /** @class */ (function (_super) {
+    __extends(ComponentInterface, _super);
+    function ComponentInterface(baseName, attributes, relativeDirectoryPath, category, prefix) {
+        if (prefix === void 0) { prefix = ""; }
+        var _this = _super.call(this, baseName, attributes, relativeDirectoryPath, prefix) || this;
+        _this.Category = category;
+        // this.Attributes.id = {
+        //     type: "number", // Components have a id field with a number
+        //     required: true,
+        // };
+        _this.updateStrapiName();
+        return _this;
+    }
+    ComponentInterface.prototype.updateStrapiName = function () {
+        this.StrapiName = "".concat(this.Category, ".").concat(this.getBaseName());
+    };
+    ComponentInterface.prototype.getInterfaceFieldsString = function () {
+        var attrs = this.getAttributes();
+        var str = '';
+        str += "  id: number;\n";
+        str += "  __component: \"".concat(this.getStrapiName(), "\";\n");
+        return str + attrs.toFieldsString();
+    };
+    return ComponentInterface;
+}(Interface_1.default));
+exports.default = ComponentInterface;

package/lib/interface/Interface.d.ts

@@ -0,0 +1,27 @@
+import Attributes from "./Attributes";
+export default class Interface {
+    protected BaseName: string;
+    private Relations;
+    private RelationNames;
+    private RelationNamesCounter;
+    private NamePrefix;
+    protected Attributes: any;
+    private RelativeDirectoryPath;
+    protected StrapiName: string;
+    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, prefix?: string);
+    protected updateStrapiName(): void;
+    getBaseName(): string;
+    getStrapiName(): string;
+    getDependencies(): any[];
+    getFullInterfaceName(): string;
+    getRelativeRootPath(): any;
+    getRelativeRootDir(): string;
+    getRelativeRootPathFile(): string;
+    setRelations(relations: Interface[]): void;
+    private getTsImports;
+    getAttributes(): Attributes;
+    attributesToString(): string;
+    getInerfaceString(): string;
+    getInterfaceFieldsString(): string;
+    toString(): string;
+}

package/lib/interface/Interface.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = require("path");
+var utils_1 = require("../utils");
+var Attributes_1 = __importDefault(require("./Attributes"));
+var Interface = /** @class */ (function () {
+    function Interface(baseName, attributes, relativeDirectoryPath, prefix) {
+        if (prefix === void 0) { prefix = ""; }
+        this.Relations = []; // Components and relations
+        this.RelationNames = {};
+        this.RelationNamesCounter = {};
+        this.NamePrefix = "";
+        this.BaseName = baseName;
+        this.updateStrapiName();
+        this.NamePrefix = prefix;
+        this.Attributes = attributes;
+        this.RelativeDirectoryPath = relativeDirectoryPath;
+    }
+    Interface.prototype.updateStrapiName = function () {
+        this.StrapiName = "api::".concat(this.BaseName, ".").concat(this.BaseName);
+    };
+    Interface.prototype.getBaseName = function () {
+        return this.BaseName;
+    };
+    Interface.prototype.getStrapiName = function () {
+        return this.StrapiName;
+    };
+    Interface.prototype.getDependencies = function () {
+        var attrs = new Attributes_1.default(this.Attributes, this.RelationNames);
+        return attrs.getDependencies(this.getStrapiName());
+    };
+    Interface.prototype.getFullInterfaceName = function () {
+        var pascalName = (0, utils_1.pascalCase)(this.BaseName);
+        return "".concat(this.NamePrefix).concat(pascalName);
+    };
+    // For typescript import from index file
+    Interface.prototype.getRelativeRootPath = function () {
+        var path = (0, path_1.join)(this.RelativeDirectoryPath, this.getBaseName());
+        return (0, utils_1.prefixDotSlash)(path);
+    };
+    Interface.prototype.getRelativeRootDir = function () {
+        var path = (0, path_1.dirname)(this.getRelativeRootPathFile());
+        return path;
+    };
+    Interface.prototype.getRelativeRootPathFile = function () {
+        return "".concat(this.getRelativeRootPath(), ".ts");
+    };
+    Interface.prototype.setRelations = function (relations) {
+        var _this = this;
+        this.Relations = relations;
+        this.RelationNames = {};
+        this.Relations.forEach(function (inter) {
+            var name = inter.getFullInterfaceName();
+            // FIXME: clean up this mess...
+            if (inter.getStrapiName() === _this.getStrapiName()) {
+            }
+            else {
+                // Avoid duplicate names
+                if (name in _this.RelationNamesCounter) {
+                    name += ++_this.RelationNamesCounter[name];
+                }
+                else {
+                    _this.RelationNamesCounter[name] = 0;
+                }
+            }
+            _this.RelationNames[inter.getStrapiName()] = [name, inter];
+        });
+    };
+    Interface.prototype.getTsImports = function () {
+        var _this = this;
+        return Object.keys(this.RelationNames).map(function (strapiName) {
+            if (strapiName === _this.getStrapiName()) {
+                return "";
+            }
+            var relationName = _this.RelationNames[strapiName][0];
+            var inter = _this.RelationNames[strapiName][1];
+            var importPath = (0, utils_1.prefixDotSlash)((0, path_1.relative)(_this.getRelativeRootDir(), inter.getRelativeRootPath()));
+            var fullName = inter.getFullInterfaceName();
+            var importNameString = fullName === relationName ? fullName : "".concat(fullName, " as ").concat(relationName);
+            return "import { ".concat(importNameString, " } from '").concat(importPath, "';");
+        }).filter(function (s) { return s; }).join("\n");
+    };
+    Interface.prototype.getAttributes = function () {
+        return new Attributes_1.default(this.Attributes, this.RelationNames);
+    };
+    Interface.prototype.attributesToString = function () {
+        var attrs = this.getAttributes();
+        return attrs.toString();
+    };
+    Interface.prototype.getInerfaceString = function () {
+        var str = "export interface ".concat(this.getFullInterfaceName(), " {\n");
+        str += this.getInterfaceFieldsString();
+        str += "}";
+        return str;
+    };
+    Interface.prototype.getInterfaceFieldsString = function () {
+        var str = '';
+        str += "  id: number;\n";
+        str += "  attributes: ".concat(this.attributesToString(), "\n");
+        return str;
+    };
+    Interface.prototype.toString = function () {
+        var strings = [
+            this.getTsImports(),
+            this.getInerfaceString()
+        ];
+        return strings.join("\n");
+    };
+    return Interface;
+}());
+exports.default = Interface;

package/lib/interface/InterfaceManager.d.ts

@@ -0,0 +1,19 @@
+export default class InterfaceManager {
+    private Interfaces;
+    private OutRoot;
+    private StrapiSrcRoot;
+    private Options;
+    static BaseOptions: {
+        prefix: string;
+        useCategoryPrefix: boolean;
+        componentPrefix: string;
+        componentPrefixOverridesPrefix: boolean;
+    };
+    constructor(outRoot: string, strapiSrcRoot: string, options?: any);
+    createInterfaces(): Promise<void>;
+    injectDependencies(): void;
+    makeFolders(): Promise<void>;
+    writeInterfaces(): Promise<void>;
+    writeIndexFile(): Promise<void>;
+    run(): Promise<void>;
+}

package/lib/interface/InterfaceManager.js

@@ -0,0 +1,236 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = require("fs");
+var promises_1 = require("fs/promises");
+var path_1 = require("path");
+var utils_1 = require("../utils");
+var ComponentInterface_1 = __importDefault(require("./ComponentInterface"));
+var Interface_1 = __importDefault(require("./Interface"));
+var schemaReader_1 = require("./schemaReader");
+var InterfaceManager = /** @class */ (function () {
+    function InterfaceManager(outRoot, strapiSrcRoot, options) {
+        if (options === void 0) { options = {}; }
+        this.Interfaces = {}; // string = strapi name
+        this.OutRoot = outRoot;
+        this.StrapiSrcRoot = strapiSrcRoot;
+        this.Options = Object.assign({}, InterfaceManager.BaseOptions, options);
+    }
+    InterfaceManager.prototype.createInterfaces = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var apiSchemasPromise, componentSchemasPromise, apiSchemas, componentSchemas;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        apiSchemasPromise = (0, schemaReader_1.getApiSchemas)(this.StrapiSrcRoot);
+                        componentSchemasPromise = (0, schemaReader_1.getComponentSchemas)(this.StrapiSrcRoot);
+                        return [4 /*yield*/, apiSchemasPromise];
+                    case 1:
+                        apiSchemas = _a.sent();
+                        apiSchemas.forEach(function (schema) {
+                            var name = schema.name, attributes = schema.attributes;
+                            var strapiName = "api::".concat(name, ".").concat(name);
+                            var inter = new Interface_1.default(name, attributes, "./", _this.Options.prefix);
+                            _this.Interfaces[strapiName] = inter;
+                        });
+                        return [4 /*yield*/, componentSchemasPromise];
+                    case 2:
+                        componentSchemas = _a.sent();
+                        componentSchemas.forEach(function (category) {
+                            var categoryName = category.category;
+                            category.schemas.forEach(function (schema) {
+                                var componentName = schema.name;
+                                var strapiName = "".concat(categoryName, ".").concat(schema.name);
+                                var componentPrefix = "".concat(_this.Options.componentPrefix).concat(_this.Options.useCategoryPrefix ? (0, utils_1.pascalCase)(categoryName) : "");
+                                var prefix = _this.Options.componentPrefixOverridesPrefix ? componentPrefix : _this.Options.prefix + componentPrefix;
+                                // TODO: make component interface
+                                var inter = new ComponentInterface_1.default(componentName, schema.attributes, "./".concat(categoryName), categoryName, prefix);
+                                _this.Interfaces[strapiName] = inter;
+                            });
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Inject dependencies into all interfaces
+    InterfaceManager.prototype.injectDependencies = function () {
+        var _this = this;
+        // console.log("Injecting dependencies")
+        Object.keys(this.Interfaces).forEach(function (strapiName) {
+            var inter = _this.Interfaces[strapiName];
+            var dependencies = inter.getDependencies();
+            // console.log(`Interfaces for ${inter.getStrapiName()} are`)
+            var interfacesToInject = dependencies.map(function (dependencyStrapiName) {
+                return _this.Interfaces[dependencyStrapiName];
+            }).filter(function (inter) { return inter; });
+            inter.setRelations(interfacesToInject);
+        });
+    };
+    InterfaceManager.prototype.makeFolders = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var componentCategories;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, schemaReader_1.getComponentCategoryFolders)(this.StrapiSrcRoot)];
+                    case 1:
+                        componentCategories = _a.sent();
+                        if (!!(0, fs_1.existsSync)(this.OutRoot)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, (0, promises_1.mkdir)(this.OutRoot, {
+                                recursive: true,
+                            })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [4 /*yield*/, Promise.all(componentCategories.map(function (category) { return __awaiter(_this, void 0, void 0, function () {
+                            var path;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        path = (0, path_1.join)(this.OutRoot, category);
+                                        if ((0, fs_1.existsSync)(path)) {
+                                            return [2 /*return*/];
+                                        }
+                                        return [4 /*yield*/, (0, promises_1.mkdir)(path)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    InterfaceManager.prototype.writeInterfaces = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var writePromises;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        writePromises = Object.keys(this.Interfaces).map(function (strapiName) { return __awaiter(_this, void 0, void 0, function () {
+                            var inter, fileData, filePath;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        inter = this.Interfaces[strapiName];
+                                        fileData = inter.toString();
+                                        filePath = (0, path_1.join)(this.OutRoot, inter.getRelativeRootPathFile());
+                                        return [4 /*yield*/, (0, promises_1.writeFile)(filePath, fileData)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        return [4 /*yield*/, Promise.all(writePromises)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    InterfaceManager.prototype.writeIndexFile = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var strings, fileData, filePath;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        strings = Object.keys(this.Interfaces).map(function (strapiName) {
+                            var inter = _this.Interfaces[strapiName];
+                            return "export * from '".concat(inter.getRelativeRootPath(), "'");
+                        });
+                        fileData = strings.join("\n");
+                        filePath = (0, path_1.join)(this.OutRoot, "index.ts");
+                        return [4 /*yield*/, (0, promises_1.writeFile)(filePath, fileData)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    InterfaceManager.prototype.run = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var createInterfacesPromise, makeFoldersPromise, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 4, , 5]);
+                        createInterfacesPromise = this.createInterfaces();
+                        makeFoldersPromise = this.makeFolders();
+                        return [4 /*yield*/, createInterfacesPromise];
+                    case 1:
+                        _a.sent();
+                        this.injectDependencies();
+                        return [4 /*yield*/, makeFoldersPromise];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, Promise.all([this.writeInterfaces(), this.writeIndexFile()])];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        err_1 = _a.sent();
+                        console.error(err_1);
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    InterfaceManager.BaseOptions = {
+        prefix: "I",
+        useCategoryPrefix: true,
+        componentPrefix: "",
+        componentPrefixOverridesPrefix: false,
+    };
+    return InterfaceManager;
+}());
+exports.default = InterfaceManager;

package/lib/interface/interfaceWriter.d.ts

@@ -0,0 +1,2 @@
+import type Interface from "./Interface";
+export default function writeInterface(inter: Interface): Promise<void>;