amxxpack 0.0.3

package/README.md

@@ -0,0 +1,49 @@
+# 📦 AMXXPack 
+Simple build system and **CLI** for **AMX Mod X** projects.
+
+# 📄 About
+
+This system will be useful for projects with multiple plugins and assets. Using the command-line interface you can build entire project with a single command. It also supports hot rebuild to keep your plugins and assets up to date during the work.
+
+
+## 📚 Features
+- ⚙ Flexible configuration
+- 🔥 Hot reload
+- 🧸 Assets builder
+
+## 🔧 Installation
+**AMXXPack** is available through the npm registry.
+Installation can be done using the `npm install` command:
+```
+npm install amxxpack
+```
+
+or install it globally to use as a system command
+```
+npm install -g amxxpack
+```
+
+## ▶ Quick start
+- Create new directory for your project
+- Open a terminal inside the project directory
+- Execute `npm init -y` command to init the package
+- Execute `npm install amxxpack --save-dev` command to install `amxxpack` locally
+- Execute `npx amxxpack init` command to create new config
+- Use `npx amxxpack build` command to build the project
+- Adding build scripts *(optional)*
+
+  To use `npm run build` and `npm run watch` to build or watch the project update the `scripts` section in `package.json`:
+  ```json
+    "scripts": {
+      "build": "amxxpack build",
+      "watch": "amxxpack build --watch"
+    }
+  ```
+
+## 📋 Commands
+- `amxxpack init` init config for a new project
+- `amxxpack build` command to build the project
+  - `--watch` flag to watch changes
+  - `--config` config file
+- `amxxpack compile <path|glob>` to compile specific plugin in the project
+  - `--config` config file

package/lib/builder/amxxpc.d.ts

@@ -0,0 +1,27 @@
+export declare enum AMXPCMessageType {
+    Echo = "echo",
+    Error = "error",
+    Warning = "warning",
+    FatalError = "fatal error"
+}
+interface IMessage {
+    filename?: string;
+    startLine?: number;
+    endLine?: number;
+    code?: number;
+    type: AMXPCMessageType;
+    text: string;
+}
+interface IParseOutputResult {
+    messages: IMessage[];
+    aborted: boolean;
+    error: boolean;
+}
+interface ICompileResult {
+    output: IParseOutputResult;
+    plugin: string;
+    error?: string;
+    success: boolean;
+}
+declare function compile(params: any): Promise<ICompileResult>;
+export default compile;

package/lib/builder/amxxpc.js

@@ -0,0 +1,122 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AMXPCMessageType = void 0;
+var path_1 = __importDefault(require("path"));
+var child_process_1 = __importDefault(require("child_process"));
+var mkdirp_1 = __importDefault(require("mkdirp"));
+var accumulator_1 = __importDefault(require("../utils/accumulator"));
+var PLUGIN_EXT = 'amxx';
+var AMXPCMessageType;
+(function (AMXPCMessageType) {
+    AMXPCMessageType["Echo"] = "echo";
+    AMXPCMessageType["Error"] = "error";
+    AMXPCMessageType["Warning"] = "warning";
+    AMXPCMessageType["FatalError"] = "fatal error";
+})(AMXPCMessageType = exports.AMXPCMessageType || (exports.AMXPCMessageType = {}));
+var MessageRegExp = {
+    filename: /([a-zA-Z0-9.\-_/:\\\s]+)/,
+    line: /\(([0-9]+)(?:\s--\s([0-9]+))?\)/,
+    type: /((?:fatal\s)?error|warning)/,
+    code: /([0-9]+)/,
+    text: /(.*)/
+};
+function buildMessageRegExp() {
+    var filename = MessageRegExp.filename, line = MessageRegExp.line, type = MessageRegExp.type, code = MessageRegExp.code, text = MessageRegExp.text;
+    var pattern = [
+        filename,
+        line,
+        /\s:\s/,
+        type,
+        /\s/,
+        code,
+        /:\s/,
+        text
+    ].map(function (r) { return r.toString().slice(1, -1); }).join('');
+    return new RegExp(pattern);
+}
+var messageRegExp = buildMessageRegExp();
+function parseLine(line) {
+    var match = line.match(messageRegExp);
+    if (!match) {
+        return { type: AMXPCMessageType.Echo, text: line };
+    }
+    var filename = match[1], startLine = match[2], endLine = match[3], type = match[4], code = match[5], text = match[6];
+    return {
+        filename: filename,
+        startLine: +startLine,
+        endLine: endLine ? +endLine : -1,
+        type: type,
+        code: +code,
+        text: text
+    };
+}
+function isAbortedEcho(line) {
+    return line.startsWith('Compilation aborted.')
+        || line.startsWith('Could not locate output file');
+}
+function parseOutput(output) {
+    var result = { messages: [], aborted: false, error: false };
+    output.split('\n').forEach(function (line) {
+        var message = parseLine(line);
+        var type = message.type;
+        if (type === AMXPCMessageType.Error || type === AMXPCMessageType.FatalError) {
+            result.error = true;
+        }
+        else if (type === AMXPCMessageType.Echo && isAbortedEcho(line)) {
+            result.error = true;
+            result.aborted = true;
+        }
+        result.messages.push(message);
+    });
+    return result;
+}
+function formatArgs(params, outPath) {
+    var includeArgs = params.includeDir instanceof Array
+        ? params.includeDir.map(function (dir) { return "-i".concat(dir); })
+        : ["-i".concat(params.includeDir)];
+    return __spreadArray([params.path, "-o".concat(outPath)], includeArgs, true);
+}
+function compile(params) {
+    var parsedPath = path_1.default.parse(params.path);
+    var fileName = "".concat(parsedPath.name, ".").concat(PLUGIN_EXT);
+    var dest = path_1.default.join(params.dest, fileName);
+    mkdirp_1.default.sync(params.dest);
+    return new Promise(function (resolve) {
+        var output = (0, accumulator_1.default)();
+        var done = function (error) {
+            var outputData = output();
+            var parsedOutput = parseOutput(outputData);
+            var errorMessage = error && error.message;
+            if (!errorMessage && parsedOutput.error) {
+                errorMessage = 'Compilation error';
+            }
+            resolve({
+                error: errorMessage,
+                plugin: fileName,
+                success: !errorMessage,
+                output: parsedOutput
+            });
+        };
+        var compilerProcess = child_process_1.default.spawn(params.compiler, formatArgs(params, dest), {
+            env: process.env,
+            cwd: path_1.default.parse(params.compiler).dir
+        });
+        compilerProcess.on('error', done);
+        compilerProcess.on('close', done);
+        compilerProcess.stdout.on('data', output);
+        compilerProcess.stderr.on('data', function (data) { return console.error(data); });
+    });
+}
+exports.default = compile;

package/lib/builder/builder.d.ts

@@ -0,0 +1,22 @@
+import { IAmxxBuilderConfig } from './types';
+export default class AmxxBuilder {
+    private logger;
+    private config;
+    constructor(config: IAmxxBuilderConfig);
+    build(): Promise<void>;
+    watch(): Promise<void>;
+    buildSrc(): Promise<void>;
+    buildInclude(): Promise<void>;
+    buildAssets(): Promise<void>;
+    watchSrc(): Promise<void>;
+    watchInclude(): Promise<void>;
+    watchAssets(): Promise<void>;
+    updatePlugin(filePath: string): Promise<void>;
+    updateScript(filePath: string): Promise<void>;
+    updateAsset(filePath: string): Promise<void>;
+    updateInclude(filePath: string): Promise<void>;
+    findPlugins(pattern: string): Promise<string[]>;
+    compilePlugin(filePath: string): Promise<void>;
+    private buildDir;
+    private watchDir;
+}

package/lib/builder/builder.js

@@ -0,0 +1,392 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
+var mkdirp_1 = __importDefault(require("mkdirp"));
+var glob_promise_1 = __importDefault(require("glob-promise"));
+var chokidar_1 = __importDefault(require("chokidar"));
+var normalize_path_1 = __importDefault(require("normalize-path"));
+var amxxpc_1 = __importStar(require("./amxxpc"));
+var logger_1 = __importDefault(require("../services/logger"));
+var constants_1 = require("./constants");
+var AmxxBuilder = /** @class */ (function () {
+    function AmxxBuilder(config) {
+        var compiler = config.compiler, input = config.input, output = config.output;
+        this.logger = new logger_1.default();
+        this.config = {
+            compiler: {
+                executable: path_1.default.resolve(compiler.executable),
+                include: compiler.include.map(function (include) { return path_1.default.resolve(include); })
+            },
+            input: {
+                scripts: path_1.default.resolve(input.scripts),
+                include: path_1.default.resolve(input.include),
+                assets: path_1.default.resolve(input.assets),
+            },
+            output: {
+                scripts: path_1.default.resolve(output.scripts),
+                plugins: path_1.default.resolve(output.plugins),
+                include: path_1.default.resolve(output.include),
+                assets: path_1.default.resolve(output.assets)
+            }
+        };
+    }
+    AmxxBuilder.prototype.build = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.logger.info('Building...');
+                        return [4 /*yield*/, this.buildAssets()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.buildInclude()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.buildSrc()];
+                    case 3:
+                        _a.sent();
+                        this.logger.success('Build finished!');
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.watch = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.watchAssets()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.watchInclude()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.watchSrc()];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.buildSrc = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.buildDir(this.config.input.scripts, constants_1.SCRIPTS_PATH_PATTERN, function (filePath) { return _this.updatePlugin(filePath); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.buildInclude = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.buildDir(this.config.input.include, constants_1.INCLUDE_PATH_PATTERN, function (filePath) { return _this.updateInclude(filePath); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.buildAssets = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.buildDir(this.config.input.assets, constants_1.ASSETS_PATH_PATTERN, function (filePath) { return _this.updateAsset(filePath); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.watchSrc = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.watchDir(this.config.input.scripts, constants_1.SCRIPTS_PATH_PATTERN, function (filePath) { return _this.updatePlugin(filePath); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.watchInclude = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.watchDir(this.config.input.include, constants_1.INCLUDE_PATH_PATTERN, function (filePath) { return _this.updateInclude(filePath); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.watchAssets = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.watchDir(this.config.input.assets, constants_1.ASSETS_PATH_PATTERN, function (filePath) { return _this.updateAsset(filePath); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.updatePlugin = function (filePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.updateScript(filePath)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.compilePlugin(filePath)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.updateScript = function (filePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var srcPath, destPath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        srcPath = path_1.default.resolve(filePath);
+                        destPath = path_1.default.join(this.config.output.scripts, path_1.default.parse(filePath).base);
+                        return [4 /*yield*/, (0, mkdirp_1.default)(this.config.output.scripts)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, fs_1.default.promises.copyFile(srcPath, destPath)];
+                    case 2:
+                        _a.sent();
+                        this.logger.info('Script updated:', (0, normalize_path_1.default)(destPath));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.updateAsset = function (filePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var srcPath, relativePath, destPath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        srcPath = path_1.default.resolve(filePath);
+                        relativePath = path_1.default.relative(this.config.input.assets, filePath);
+                        destPath = path_1.default.join(this.config.output.assets, relativePath);
+                        return [4 /*yield*/, (0, mkdirp_1.default)(path_1.default.parse(destPath).dir)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, fs_1.default.promises.copyFile(srcPath, destPath)];
+                    case 2:
+                        _a.sent();
+                        this.logger.info('Asset updated', (0, normalize_path_1.default)(destPath));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.updateInclude = function (filePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var srcPath, destPath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        srcPath = path_1.default.resolve(filePath);
+                        destPath = path_1.default.join(this.config.output.include, path_1.default.parse(filePath).base);
+                        return [4 /*yield*/, (0, mkdirp_1.default)(this.config.output.include)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, fs_1.default.promises.copyFile(srcPath, destPath)];
+                    case 2:
+                        _a.sent();
+                        this.logger.info('Include updated:', (0, normalize_path_1.default)(destPath));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.findPlugins = function (pattern) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pathPattern, matches;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pathPattern = path_1.default.join(this.config.input.scripts, '**', pattern);
+                        return [4 /*yield*/, (0, glob_promise_1.default)(pathPattern)];
+                    case 1:
+                        matches = _a.sent();
+                        return [2 /*return*/, matches];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.compilePlugin = function (filePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var srcPath, destDir, relateiveSrcPath, result, destPath, relativeFilePath;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        srcPath = path_1.default.resolve(filePath);
+                        destDir = path_1.default.resolve(this.config.output.plugins);
+                        relateiveSrcPath = path_1.default.relative(process.cwd(), srcPath);
+                        return [4 /*yield*/, (0, mkdirp_1.default)(destDir)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, (0, amxxpc_1.default)({
+                                path: srcPath,
+                                dest: destDir,
+                                compiler: this.config.compiler.executable,
+                                includeDir: __spreadArray(__spreadArray([], this.config.compiler.include, true), [
+                                    this.config.input.include,
+                                ], false)
+                            })];
+                    case 2:
+                        result = _a.sent();
+                        result.output.messages.forEach(function (message) {
+                            var startLine = message.startLine, type = message.type, code = message.code, text = message.text;
+                            if (type === amxxpc_1.AMXPCMessageType.Error || type === amxxpc_1.AMXPCMessageType.FatalError) {
+                                _this.logger.error("".concat((0, normalize_path_1.default)(relateiveSrcPath), "(").concat(startLine, ")"), type, code, ':', text);
+                            }
+                            else if (type === amxxpc_1.AMXPCMessageType.Warning) {
+                                _this.logger.warn("".concat((0, normalize_path_1.default)(relateiveSrcPath), "(").concat(startLine, ")"), type, code, ':', text);
+                            }
+                            else if (type === amxxpc_1.AMXPCMessageType.Echo) {
+                                _this.logger.debug(text);
+                            }
+                        });
+                        if (result.success) {
+                            destPath = path_1.default.join(destDir, result.plugin);
+                            relativeFilePath = path_1.default.relative(process.cwd(), filePath);
+                            this.logger.success('Compilation success:', (0, normalize_path_1.default)(relativeFilePath));
+                            this.logger.info('Plugin updated:', (0, normalize_path_1.default)(destPath));
+                        }
+                        else {
+                            throw new Error("Failed to compile ".concat((0, normalize_path_1.default)(relateiveSrcPath), " : \"").concat(result.error, "\""));
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.buildDir = function (baseDir, pattern, cb) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pathPattern, matches;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pathPattern = path_1.default.join(baseDir, pattern);
+                        return [4 /*yield*/, (0, glob_promise_1.default)(pathPattern, { nodir: true })];
+                    case 1:
+                        matches = _a.sent();
+                        return [4 /*yield*/, matches.reduce(function (acc, match) { return acc.then(function () { return cb(match); }); }, Promise.resolve())];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmxxBuilder.prototype.watchDir = function (baseDir, pattern, cb) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pathPattern, watcher, updateFn;
+            var _this = this;
+            return __generator(this, function (_a) {
+                pathPattern = path_1.default.join(baseDir, pattern);
+                watcher = chokidar_1.default.watch(pathPattern, { ignoreInitial: true });
+                updateFn = function (filePath) { return cb(filePath).catch(function (err) { return _this.logger.error(err.message); }); };
+                watcher.on('add', updateFn);
+                watcher.on('change', updateFn);
+                return [2 /*return*/];
+            });
+        });
+    };
+    return AmxxBuilder;
+}());
+exports.default = AmxxBuilder;

package/lib/builder/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const SCRIPTS_PATH_PATTERN = "**/*.sma";
+export declare const INCLUDE_PATH_PATTERN = "**/*.inc";
+export declare const ASSETS_PATH_PATTERN = "**/*.*";

package/lib/builder/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASSETS_PATH_PATTERN = exports.INCLUDE_PATH_PATTERN = exports.SCRIPTS_PATH_PATTERN = void 0;
+exports.SCRIPTS_PATH_PATTERN = '**/*.sma';
+exports.INCLUDE_PATH_PATTERN = '**/*.inc';
+exports.ASSETS_PATH_PATTERN = '**/*.*';

package/lib/builder/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './builder';
+export * from './types';

package/lib/builder/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+// eslint-disable-next-line no-restricted-exports
+var builder_1 = require("./builder");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(builder_1).default; } });
+__exportStar(require("./types"), exports);

package/lib/builder/types.d.ts

@@ -0,0 +1,17 @@
+export interface IAmxxBuilderConfig {
+    compiler: {
+        executable: string;
+        include: string[];
+    };
+    input: {
+        scripts: string;
+        include: string;
+        assets: string;
+    };
+    output: {
+        scripts: string;
+        plugins: string;
+        include: string;
+        assets: string;
+    };
+}

package/lib/builder/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cli/controller.d.ts

@@ -0,0 +1,10 @@
+import AmxxBuilder, { IAmxxBuilderConfig } from '../builder';
+declare class Controller {
+    loadConfig(configPath: string): Promise<IAmxxBuilderConfig>;
+    createBuilder(configPath: string): Promise<AmxxBuilder>;
+    init(projectDir: string): Promise<void>;
+    compile(scriptPath: string, configPath: string): Promise<void>;
+    build(configPath: string, watch: boolean): Promise<void>;
+}
+declare const _default: Controller;
+export default _default;

package/lib/cli/controller.js

@@ -0,0 +1,163 @@
+"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 path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
+var mkdirp_1 = __importDefault(require("mkdirp"));
+// import childProcess from 'child_process';
+var builder_1 = __importDefault(require("../builder"));
+function resolveConfigPath(configPath) {
+    return path_1.default.isAbsolute(configPath) ? configPath : path_1.default.join(process.cwd(), configPath);
+}
+var Controller = /** @class */ (function () {
+    function Controller() {
+    }
+    Controller.prototype.loadConfig = function (configPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resolvedPath, config;
+            return __generator(this, function (_a) {
+                resolvedPath = resolveConfigPath(configPath);
+                if (!fs_1.default.existsSync(resolvedPath)) {
+                    // eslint-disable-next-line no-console
+                    console.log('Project is not initialzied! Use "init" command to initialize the project!');
+                    process.exit(1);
+                }
+                config = require(resolvedPath);
+                return [2 /*return*/, config];
+            });
+        });
+    };
+    Controller.prototype.createBuilder = function (configPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var config, builder;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.loadConfig(configPath)];
+                    case 1:
+                        config = _a.sent();
+                        builder = new builder_1.default(config);
+                        return [2 /*return*/, builder];
+                }
+            });
+        });
+    };
+    Controller.prototype.init = function (projectDir) {
+        return __awaiter(this, void 0, void 0, function () {
+            var configPath, config, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        configPath = path_1.default.join(projectDir, '.amxxpack.json');
+                        return [4 /*yield*/, fs_1.default.promises.copyFile(path_1.default.join(__dirname, '../../resources/default-config.json'), configPath)];
+                    case 1:
+                        _c.sent();
+                        _b = (_a = JSON).parse;
+                        return [4 /*yield*/, fs_1.default.promises.readFile(configPath, 'utf8')];
+                    case 2:
+                        config = _b.apply(_a, [_c.sent()]);
+                        return [4 /*yield*/, (0, mkdirp_1.default)(path_1.default.join(projectDir, config.input.assets))];
+                    case 3:
+                        _c.sent();
+                        return [4 /*yield*/, (0, mkdirp_1.default)(path_1.default.join(projectDir, config.input.include))];
+                    case 4:
+                        _c.sent();
+                        return [4 /*yield*/, (0, mkdirp_1.default)(path_1.default.join(projectDir, config.input.scripts))];
+                    case 5:
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Controller.prototype.compile = function (scriptPath, configPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var builder, matches;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.createBuilder(configPath)];
+                    case 1:
+                        builder = _a.sent();
+                        return [4 /*yield*/, builder.findPlugins(scriptPath)];
+                    case 2:
+                        matches = _a.sent();
+                        matches.map(function (filePath) { return __awaiter(_this, void 0, void 0, function () {
+                            var srcPath;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        srcPath = path_1.default.resolve(filePath);
+                                        return [4 /*yield*/, builder.compilePlugin(srcPath)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Controller.prototype.build = function (configPath, watch) {
+        return __awaiter(this, void 0, void 0, function () {
+            var builder;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.createBuilder(configPath)];
+                    case 1:
+                        builder = _a.sent();
+                        return [4 /*yield*/, builder.build()];
+                    case 2:
+                        _a.sent();
+                        if (!watch) return [3 /*break*/, 4];
+                        return [4 /*yield*/, builder.watch()];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return Controller;
+}());
+exports.default = new Controller();

package/lib/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/cli/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var program_1 = __importDefault(require("./program"));
+program_1.default.parse();

package/lib/cli/program.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+declare const program: Command;
+export default program;

package/lib/cli/program.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+"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 commander_1 = require("commander");
+var controller_1 = __importDefault(require("./controller"));
+var program = new commander_1.Command();
+program
+    .name('AMXXPack CLI')
+    .description('Simple AmxModX CLI');
+program
+    .command('init')
+    .action(function () { return __awaiter(void 0, void 0, void 0, function () {
+    var projectDir;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                projectDir = process.cwd();
+                return [4 /*yield*/, controller_1.default.init(projectDir)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+program
+    .command('compile')
+    .argument('<path>', 'Script path or glob')
+    .option('--config, -c', 'Config file', '.amxxpack.json')
+    .action(function (str, options) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, controller_1.default.compile(str, options.C)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+program
+    .command('build')
+    .option('--watch, -w', 'Watch project')
+    .option('--config, -c', 'Config file', '.amxxpack.json')
+    .action(function (str, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var opts;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                opts = options.opts();
+                return [4 /*yield*/, controller_1.default.build(opts.C, opts.W)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+// program
+//   .command('create')
+//   .argument('<name>', 'Project name')
+//   .action(async (name: string) => {
+//     await controller.createProject(name);
+//   });
+exports.default = program;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './builder';
+export * from './builder';

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+// eslint-disable-next-line no-restricted-exports
+var builder_1 = require("./builder");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(builder_1).default; } });
+__exportStar(require("./builder"), exports);

package/lib/services/logger.d.ts

@@ -0,0 +1,22 @@
+export interface ILoggerOptions {
+    debug?: boolean;
+}
+export declare enum LogLevel {
+    Debug = "debug",
+    Success = "success",
+    Info = "info",
+    Warning = "warning",
+    Error = "error"
+}
+export default class Logger {
+    private debugMode;
+    constructor(options?: ILoggerOptions);
+    debug(...args: any[]): void;
+    success(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    out(level: LogLevel, ...args: any[]): void;
+    private colorifyMessageByLevel;
+    private getLevelLabel;
+}

package/lib/services/logger.js

@@ -0,0 +1,104 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+var safe_1 = __importDefault(require("colors/safe"));
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["Debug"] = "debug";
+    LogLevel["Success"] = "success";
+    LogLevel["Info"] = "info";
+    LogLevel["Warning"] = "warning";
+    LogLevel["Error"] = "error";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+var Logger = /** @class */ (function () {
+    function Logger(options) {
+        if (options === void 0) { options = {}; }
+        this.debugMode = false;
+        this.debugMode = options.debug || false;
+    }
+    Logger.prototype.debug = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        this.out.apply(this, __spreadArray([LogLevel.Debug], args, false));
+    };
+    Logger.prototype.success = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        this.out.apply(this, __spreadArray([LogLevel.Success], args, false));
+    };
+    Logger.prototype.info = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        this.out.apply(this, __spreadArray([LogLevel.Info], args, false));
+    };
+    Logger.prototype.warn = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        this.out.apply(this, __spreadArray([LogLevel.Warning], args, false));
+    };
+    Logger.prototype.error = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        this.out.apply(this, __spreadArray([LogLevel.Error], args, false));
+    };
+    Logger.prototype.out = function (level) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (level === 'debug' && !this.debugMode) {
+            return;
+        }
+        var message = args
+            .map(function (arg) { return ((arg instanceof Object) ? JSON.stringify(arg) : arg); })
+            .join(' ');
+        var label = this.getLevelLabel(level);
+        var coloredMessage = this.colorifyMessageByLevel(level, message);
+        // eslint-disable-next-line no-console
+        console.log(label, coloredMessage);
+    };
+    Logger.prototype.colorifyMessageByLevel = function (level, message) {
+        switch (level) {
+            case LogLevel.Debug: return safe_1.default.grey(message);
+            case LogLevel.Success: return safe_1.default.white(message);
+            case LogLevel.Info: return safe_1.default.grey(message);
+            case LogLevel.Warning: return safe_1.default.white(message);
+            case LogLevel.Error: return safe_1.default.white(message);
+        }
+        return message;
+    };
+    Logger.prototype.getLevelLabel = function (level) {
+        switch (level) {
+            case LogLevel.Debug: return safe_1.default.grey('[DEBUG]');
+            case LogLevel.Success: return safe_1.default.green('[SUCCESS]');
+            case LogLevel.Info: return safe_1.default.cyan('[INFO]');
+            case LogLevel.Warning: return safe_1.default.yellow('[WARNING]');
+            case LogLevel.Error: return safe_1.default.red('[ERROR]');
+        }
+        return '';
+    };
+    return Logger;
+}());
+exports.default = Logger;

package/lib/utils/accumulator.d.ts

@@ -0,0 +1 @@
+export default function accumulator(): (data?: string | undefined) => string;

package/lib/utils/accumulator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function accumulator() {
+    var value = '';
+    return function (data) {
+        value += (data || '');
+        return value;
+    };
+}
+exports.default = accumulator;

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "amxxpack",
+  "description": "AMXXPack",
+  "author": "Hedgehog Fog",
+  "version": "0.0.3",
+  "license": "MIT",
+  "main": "lib/builder/index.js",
+  "types": "lib/builder/index.d.ts",
+  "files": [
+    "lib/**/*",
+    "resources/**/*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint",
+    "prepare": "npm run build"
+  },
+  "bin": {
+    "amxxpack": "./lib/cli/index.js"
+  },
+  "keywords": [
+    "amx",
+    "amxx",
+    "amxmodx",
+    "cli",
+    "pawn"
+  ],
+  "dependencies": {
+    "chalk": "^5.0.0",
+    "chokidar": "^3.5.3",
+    "colors": "^1.4.0",
+    "commander": "^9.0.0",
+    "glob": "^7.2.0",
+    "glob-promise": "^4.2.2",
+    "mkdirp": "^1.0.4",
+    "normalize-path": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/chokidar": "^2.1.3",
+    "@types/colors": "^1.2.1",
+    "@types/commander": "^2.12.2",
+    "@types/mkdirp": "^1.0.2",
+    "@types/normalize-path": "^3.0.0",
+    "@typescript-eslint/eslint-plugin": "^5.12.0",
+    "@typescript-eslint/parser": "^5.12.0",
+    "eslint": "^8.9.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-airbnb-typescript": "^16.1.0",
+    "eslint-plugin-import": "^2.25.4",
+    "typescript": "^4.5.5"
+  }
+}

package/resources/default-config.json

@@ -0,0 +1,19 @@
+{
+  "compiler": { 
+    "executable": "./compiler/amxxpc.exe",
+    "include": [
+      "./compiler/include"
+    ]
+  },
+  "input": {
+    "scripts": "./src/scripts",
+    "include": "./src/include",
+    "assets": "./assets"
+  },
+  "output": {
+    "scripts": "./dist/addons/amxmodx/scripting",
+    "plugins": "./dist/addons/amxmodx/plugins",
+    "include": "./dist/addons/amxmodx/scripting/include",
+    "assets": "./dist"
+  }
+}