@oak-digital/types-4-strapi-2 0.2.1 → 0.2.2

package/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true

package/.eslintrc.json

@@ -0,0 +1,52 @@
+{
+    "env": {
+        "es2021": true,
+        "node": true
+    },
+    "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/recommended"
+    ],
+    "overrides": [
+    ],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "plugins": [
+        "@typescript-eslint"
+    ],
+    "rules": {
+        "@typescript-eslint/no-explicit-any": "off",
+        "no-case-declarations": "off",
+        "@typescript-eslint/no-unused-vars": "off",
+        "default-case-last": ["error"],
+        "eqeqeq": ["error", "always"],
+        "no-lonely-if": ["error"],
+        "no-magic-numbers": ["warn", {
+            "ignoreArrayIndexes": true,
+            "ignore": [-1, 0, 1]
+        }],
+        "no-return-assign": ["error", "always"],
+        "no-return-await": ["error"],
+        "no-var": ["error"],
+        "no-cond-assign": ["error", "always"],
+        "indent": [
+            "error",
+            4
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "single"
+        ],
+        "semi": [
+            "error",
+            "always"
+        ]
+    }
+}

package/.prettierrc.json

@@ -0,0 +1,7 @@
+{
+    "parser": "typescript",
+    "semi": true,
+    "singleQuote": true,
+    "bracketSameLine": false,
+    "trailingComma": "es5"
+}

package/README.md

@@ -41,11 +41,11 @@ This can be done with the `--out` flag like in the following example.
 * Generate typescript interfaces for all your api content-types and components
 * Generate typescript interfaces for builtin types such as `Media` and `MediaFormat`
 * Select input and output directory
+* Prettier formatting and ability to use your own `.prettierrc`.
 
 ### Planned features
 
 * Support if you are using other plugins, such as `url-alias`, which should add extra fields for some interfaces.
-* Nicer formatted interfaces
 
 ## Help
 

package/lib/.prettierrc.json

@@ -0,0 +1,7 @@
+{
+    "parser": "typescript",
+    "semi": true,
+    "singleQuote": true,
+    "bracketSameLine": false,
+    "trailingComma": "es5"
+}

package/lib/index.js

@@ -6,16 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var commander_1 = require("commander");
 var InterfaceManager_1 = __importDefault(require("./interface/InterfaceManager"));
 commander_1.program
-    .name("t4s");
+    .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')
-    .option('--component-prefix <prefix>', 'A prefix for components', "");
+    .option('--component-prefix <prefix>', 'A prefix for components', '')
+    .option('--prettier <file>', 'The prettier config file to use for formatting typescript interfaces');
 commander_1.program.parse();
 var options = commander_1.program.opts();
-var input = options.in, out = options.out, componentPrefix = options.componentPrefix;
+var input = options.in, out = options.out, componentPrefix = options.componentPrefix, prettierFile = options.prettier;
 var manager = new InterfaceManager_1.default(out, input, {
     componentPrefix: componentPrefix,
+    prettierFile: prettierFile,
 });
 manager.run().catch(function (err) {
     console.error(err);

package/lib/interface/InterfaceManager.d.ts

@@ -3,6 +3,7 @@ export default class InterfaceManager {
     private OutRoot;
     private StrapiSrcRoot;
     private Options;
+    private PrettierOptions;
     static BaseOptions: {
         prefix: string;
         useCategoryPrefix: boolean;
@@ -10,8 +11,10 @@ export default class InterfaceManager {
         componentPrefixOverridesPrefix: boolean;
         builtinsPrefix: string;
         builtinsPrefixOverridesPrefix: boolean;
+        prettierFile: any;
     };
     constructor(outRoot: string, strapiSrcRoot: string, options?: any);
+    loadPrettierConfig(): Promise<void>;
     createInterfaces(): Promise<void>;
     createBuiltinInterfaces(): void;
     injectDependencies(): void;

package/lib/interface/InterfaceManager.js

@@ -47,6 +47,7 @@ var builtinInterfaces_1 = require("./builtinInterfaces");
 var ComponentInterface_1 = __importDefault(require("./ComponentInterface"));
 var Interface_1 = __importDefault(require("./Interface"));
 var schemaReader_1 = require("./schemaReader");
+var prettier_1 = __importDefault(require("prettier"));
 var InterfaceManager = /** @class */ (function () {
     function InterfaceManager(outRoot, strapiSrcRoot, options) {
         if (options === void 0) { options = {}; }
@@ -55,6 +56,28 @@ var InterfaceManager = /** @class */ (function () {
         this.StrapiSrcRoot = strapiSrcRoot;
         this.Options = Object.assign({}, InterfaceManager.BaseOptions, options);
     }
+    InterfaceManager.prototype.loadPrettierConfig = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var defaultOptions, resolved;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        defaultOptions = {
+                            parser: 'typescript',
+                        };
+                        if (!this.Options.prettierFile) {
+                            this.PrettierOptions = defaultOptions;
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, prettier_1.default.resolveConfig(this.Options.prettierFile)];
+                    case 1:
+                        resolved = _a.sent();
+                        this.PrettierOptions = Object.assign({}, defaultOptions, resolved);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     InterfaceManager.prototype.createInterfaces = function () {
         return __awaiter(this, void 0, void 0, function () {
             var apiSchemasPromise, componentSchemasPromise, apiSchemas, componentSchemas;
@@ -70,7 +93,7 @@ var InterfaceManager = /** @class */ (function () {
                         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);
+                            var inter = new Interface_1.default(name, attributes, './', _this.Options.prefix);
                             _this.Interfaces[strapiName] = inter;
                         });
                         return [4 /*yield*/, componentSchemasPromise];
@@ -81,7 +104,7 @@ var InterfaceManager = /** @class */ (function () {
                             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 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);
@@ -95,7 +118,7 @@ var InterfaceManager = /** @class */ (function () {
     };
     InterfaceManager.prototype.createBuiltinInterfaces = function () {
         var _this = this;
-        var outDir = "./builtins";
+        var outDir = './builtins';
         var builtinInterfaces = [];
         builtinInterfaces.push((0, builtinInterfaces_1.createMediaInterface)(outDir, this.Options.prefix));
         builtinInterfaces.push((0, builtinInterfaces_1.createMediaFormatInterface)(outDir, this.Options.prefix));
@@ -152,9 +175,9 @@ var InterfaceManager = /** @class */ (function () {
                             });
                         }); });
                         promises.push.apply(promises, componentCategoriesPromises);
-                        builtinsPath = (0, path_1.join)(this.OutRoot, "builtins");
+                        builtinsPath = (0, path_1.join)(this.OutRoot, 'builtins');
                         if (!(0, fs_1.existsSync)(builtinsPath)) {
-                            promises.push((0, promises_1.mkdir)((0, path_1.join)(this.OutRoot, "builtins")));
+                            promises.push((0, promises_1.mkdir)((0, path_1.join)(this.OutRoot, 'builtins')));
                         }
                         return [4 /*yield*/, Promise.all(promises)];
                     case 4:
@@ -172,14 +195,15 @@ var InterfaceManager = /** @class */ (function () {
                 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;
+                            var inter, fileData, formattedFileData, filePath;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
                                         inter = this.Interfaces[strapiName];
                                         fileData = inter.toString();
+                                        formattedFileData = prettier_1.default.format(fileData, this.PrettierOptions);
                                         filePath = (0, path_1.join)(this.OutRoot, inter.getRelativeRootPathFile());
-                                        return [4 /*yield*/, (0, promises_1.writeFile)(filePath, fileData)];
+                                        return [4 /*yield*/, (0, promises_1.writeFile)(filePath, formattedFileData)];
                                     case 1:
                                         _a.sent();
                                         return [2 /*return*/];
@@ -196,7 +220,7 @@ var InterfaceManager = /** @class */ (function () {
     };
     InterfaceManager.prototype.writeIndexFile = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var strings, fileData, filePath;
+            var strings, fileData, formattedFileData, filePath;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -205,9 +229,10 @@ var InterfaceManager = /** @class */ (function () {
                             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)];
+                        fileData = strings.join('\n');
+                        formattedFileData = prettier_1.default.format(fileData, this.PrettierOptions);
+                        filePath = (0, path_1.join)(this.OutRoot, 'index.ts');
+                        return [4 /*yield*/, (0, promises_1.writeFile)(filePath, formattedFileData)];
                     case 1:
                         _a.sent();
                         return [2 /*return*/];
@@ -217,20 +242,21 @@ var InterfaceManager = /** @class */ (function () {
     };
     InterfaceManager.prototype.run = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var createInterfacesPromise, makeFoldersPromise, err_1;
+            var createInterfacesPromise, makeFoldersPromise, loadPrettierPromise, err_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 4, , 5]);
                         createInterfacesPromise = this.createInterfaces();
                         makeFoldersPromise = this.makeFolders();
+                        loadPrettierPromise = this.loadPrettierConfig();
                         this.createBuiltinInterfaces();
                         return [4 /*yield*/, createInterfacesPromise];
                     case 1:
                         _a.sent();
                         // Create all interfaces before injecting
                         this.injectDependencies();
-                        return [4 /*yield*/, makeFoldersPromise];
+                        return [4 /*yield*/, Promise.all([makeFoldersPromise, loadPrettierPromise])];
                     case 2:
                         _a.sent();
                         return [4 /*yield*/, Promise.all([this.writeInterfaces(), this.writeIndexFile()])];
@@ -247,12 +273,13 @@ var InterfaceManager = /** @class */ (function () {
         });
     };
     InterfaceManager.BaseOptions = {
-        prefix: "I",
+        prefix: 'I',
         useCategoryPrefix: true,
-        componentPrefix: "",
+        componentPrefix: '',
         componentPrefixOverridesPrefix: false,
-        builtinsPrefix: "",
-        builtinsPrefixOverridesPrefix: false // TODO: make this work
+        builtinsPrefix: '',
+        builtinsPrefixOverridesPrefix: false,
+        prettierFile: null,
     };
     return InterfaceManager;
 }());

package/lib/src/index.d.ts

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

package/lib/src/index.js

@@ -0,0 +1,25 @@
+"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')
+    .option('--component-prefix <prefix>', 'A prefix for components', '')
+    .option('--prettier <file>', 'The prettier config file to use for formatting typescript interfaces');
+commander_1.program.parse();
+var options = commander_1.program.opts();
+console.log(options);
+var input = options.in, out = options.out, componentPrefix = options.componentPrefix, prettierFile = options.prettier;
+var manager = new InterfaceManager_1.default(out, input, {
+    componentPrefix: componentPrefix,
+    prettierFile: prettierFile,
+});
+manager.run().catch(function (err) {
+    console.error(err);
+});

package/lib/src/interface/Attributes.d.ts

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

package/lib/src/interface/Attributes.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Attributes = /** @class */ (function () {
+    function Attributes(attr, relationNames) {
+        this.RelationNames = {};
+        this.Attrs = attr;
+        this.RelationNames = relationNames;
+    }
+    Attributes.prototype.isAttributeOptional = function (attr) {
+        // If it is a component / relation / dynamiczone it is always optional due to population
+        switch (attr.type) {
+            case 'nested':
+                return attr.nullable === true;
+            case 'component':
+            case 'dynamiczone':
+            case 'relation':
+                return true;
+            default:
+                break;
+        }
+        return false;
+    };
+    Attributes.prototype.getDependencies = function () {
+        var dependencies = [];
+        for (var attrName in this.Attrs) {
+            var attr = this.Attrs[attrName];
+            var dependencyNames = [];
+            switch (attr.type) {
+                case 'nested':
+                    var attrs = new Attributes(attr.fields, this.RelationNames);
+                    dependencyNames.push.apply(dependencyNames, attrs.getDependencies());
+                    break;
+                case 'relation':
+                    dependencyNames.push(attr.target);
+                    break;
+                case 'component':
+                    dependencyNames.push(attr.component);
+                    break;
+                case 'media':
+                    dependencyNames.push('builtins::Media');
+                    break;
+                default:
+                    continue;
+            }
+            // // If the current dependency is the interface itself, do not report it as a dependency
+            // if (dependencyName === strapiName) {
+            //     continue;
+            // }
+            dependencyNames.forEach(function (dependencyName) {
+                if (!dependencies.includes(dependencyName)) {
+                    dependencies.push(dependencyName);
+                }
+            });
+        }
+        return dependencies;
+    };
+    Attributes.prototype.attributeToString = function (attrName, attr) {
+        var _a, _b;
+        var optionalString = this.isAttributeOptional(attr) ? '?' : '';
+        var str = "    ".concat(attrName).concat(optionalString, ": ");
+        var isArray = false;
+        switch (attr.type) {
+            // types-4-strapi-2 specific, used for builtin types
+            case 'nested':
+                // Be careful with recursion
+                // console.log(attr);
+                var newAttrs = new Attributes(attr.fields, this.RelationNames);
+                str += newAttrs.toString();
+                break;
+            case 'relation':
+                var apiName = attr.target;
+                // console.log(this.RelationNames, apiName)
+                var dependencyName = this.RelationNames[apiName].name;
+                isArray = attr.relation.endsWith('ToMany');
+                str += dependencyName;
+                break;
+            case 'component':
+                var componentName = attr.component;
+                var relationNameObj = this.RelationNames[componentName];
+                var dependencyComponentName = relationNameObj.name;
+                isArray = (_a = attr.repeatable) !== null && _a !== void 0 ? _a : false;
+                str += dependencyComponentName;
+                break;
+            case 'media':
+                var mediaOptional = attr.required !== true ? '?' : '';
+                str += "{ data".concat(mediaOptional, ": ").concat(this.RelationNames['builtins::Media'].name, "; }");
+                isArray = (_b = attr.multiple) !== null && _b !== void 0 ? _b : false;
+                break;
+            case 'password':
+                return null;
+            case 'enumeration':
+                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':
+            case 'text':
+            case 'richtext':
+            case 'email':
+            case 'uid':
+                str += 'string';
+                break;
+            case 'integer':
+            case 'biginteger':
+            case 'decimal':
+            case 'float':
+                str += 'number';
+                break;
+            case 'date':
+            case 'datetime':
+            case 'time':
+                str += 'Date';
+                break;
+            case 'boolean':
+                str += attr.type;
+                break;
+            case 'json':
+            default:
+                str += 'any';
+                break;
+        }
+        var isArrayString = isArray ? '[]' : '';
+        str += "".concat(isArrayString, ";");
+        return str;
+    };
+    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);
+        }
+        return strings.map(function (s) { return "".concat(s, "\n"); }).join('');
+    };
+    Attributes.prototype.toString = function () {
+        var strings = ['{'];
+        strings.push(this.toFieldsString());
+        strings.push('}');
+        return strings.join('\n');
+    };
+    return Attributes;
+}());
+exports.default = Attributes;

package/lib/src/interface/BuiltinComponentInterface.d.ts

@@ -0,0 +1,5 @@
+import ComponentInterface from './ComponentInterface';
+export default class BuiltinComponentInterface extends ComponentInterface {
+    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, prefix?: string);
+    updateStrapiName(): void;
+}

package/lib/src/interface/BuiltinComponentInterface.js

@@ -0,0 +1,36 @@
+"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 ComponentInterface_1 = __importDefault(require("./ComponentInterface"));
+var BuiltinComponentInterface = /** @class */ (function (_super) {
+    __extends(BuiltinComponentInterface, _super);
+    function BuiltinComponentInterface(baseName, attributes, relativeDirectoryPath, prefix) {
+        if (prefix === void 0) { prefix = ''; }
+        return _super.call(this, baseName, attributes, relativeDirectoryPath, 'builtins', prefix, {
+            hasId: false,
+            hasComponent: false,
+        }) || this;
+    }
+    BuiltinComponentInterface.prototype.updateStrapiName = function () {
+        this.StrapiName = "builtins::".concat(this.BaseName);
+    };
+    return BuiltinComponentInterface;
+}(ComponentInterface_1.default));
+exports.default = BuiltinComponentInterface;

package/lib/src/interface/BuiltinInterface.d.ts

@@ -0,0 +1,5 @@
+import Interface from './Interface';
+export default class BuiltinInterface extends Interface {
+    constructor(baseName: string, attributes: any, relativeDirectoryPath: string, prefix?: string);
+    updateStrapiName(): void;
+}

package/lib/src/interface/BuiltinInterface.js

@@ -0,0 +1,33 @@
+"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 BuiltinInterface = /** @class */ (function (_super) {
+    __extends(BuiltinInterface, _super);
+    function BuiltinInterface(baseName, attributes, relativeDirectoryPath, prefix) {
+        if (prefix === void 0) { prefix = ''; }
+        return _super.call(this, baseName, attributes, relativeDirectoryPath, prefix) || this;
+    }
+    BuiltinInterface.prototype.updateStrapiName = function () {
+        this.StrapiName = "builtins::".concat(this.BaseName);
+    };
+    return BuiltinInterface;
+}(Interface_1.default));
+exports.default = BuiltinInterface;

package/lib/src/interface/ComponentInterface.d.ts

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

package/lib/src/interface/ComponentInterface.js

@@ -0,0 +1,58 @@
+"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, options) {
+        if (prefix === void 0) { prefix = ''; }
+        if (options === void 0) { options = {}; }
+        var _this = _super.call(this, baseName, attributes, relativeDirectoryPath, prefix) || this;
+        _this.Options = {
+            hasId: true,
+            hasComponent: true,
+        };
+        _this.Category = category;
+        // this.Attributes.id = {
+        //     type: "number", // Components have a id field with a number
+        //     required: true,
+        // };
+        _this.updateStrapiName();
+        Object.assign(_this.Options, options);
+        return _this;
+    }
+    ComponentInterface.prototype.updateStrapiName = function () {
+        this.StrapiName = "".concat(this.Category, ".").concat(this.getBaseName());
+    };
+    ComponentInterface.prototype.getInterfaceFieldsString = function () {
+        var attrs = this.getAttributes();
+        var str = '';
+        var _a = this.Options, hasId = _a.hasId, hasComponent = _a.hasComponent;
+        if (hasId) {
+            str += '  id: number;\n';
+        }
+        if (hasComponent) {
+            str += "  __component: \"".concat(this.getStrapiName(), "\";\n");
+        }
+        return str + attrs.toFieldsString();
+    };
+    return ComponentInterface;
+}(Interface_1.default));
+exports.default = ComponentInterface;