amxxpack 1.4.2 → 1.4.4

package/README.md

@@ -60,6 +60,7 @@ npm install -g amxxpack
   - `--lib` - library name
   - `--include` - include list separated by a comma
   - `--overwrite` - overwrite the file if it already exists
+- `amxxpack cache clean` - clean amxxpack cache
 - `amxpack i` - alias to `install` command
 - `amxpack g` - alias to `generate` command
 - `amxpack b` - alias to `build` command

package/lib/builder/builder.d.ts

@@ -13,7 +13,7 @@ export default class AmxxBuilder {
     buildInclude(): Promise<void>;
     buildAssets(): Promise<void>;
     watchScripts(compileOptions: CompileOptions): Promise<void>;
-    watchInclude(): Promise<void>;
+    watchInclude(compileOptions: CompileOptions): Promise<void>;
     watchAssets(): Promise<void>;
     updatePlugin(srcDir: string, srcFile: string, compileOptions: CompileOptions): Promise<boolean>;
     updateScript(srcDir: string, srcFile: string): Promise<void>;

package/lib/builder/builder.js

@@ -131,7 +131,7 @@ var AmxxBuilder = /** @class */ (function () {
                     case 0: return [4 /*yield*/, this.watchAssets()];
                     case 1:
                         _a.sent();
-                        return [4 /*yield*/, this.watchInclude()];
+                        return [4 /*yield*/, this.watchInclude(compileOptions)];
                     case 2:
                         _a.sent();
                         return [4 /*yield*/, this.watchScripts(compileOptions)];
@@ -300,12 +300,26 @@ var AmxxBuilder = /** @class */ (function () {
             });
         });
     };
-    AmxxBuilder.prototype.watchInclude = function () {
+    AmxxBuilder.prototype.watchInclude = function (compileOptions) {
         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.projectConfig.input.include, constants_1.INCLUDE_PATH_PATTERN, function (filePath) { return _this.updateInclude(filePath); })];
+                    case 0: return [4 /*yield*/, this.watchDir(this.projectConfig.input.include, constants_1.INCLUDE_PATH_PATTERN, function (filePath) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.updateInclude(filePath)];
+                                    case 1:
+                                        _a.sent();
+                                        if (!!compileOptions.noCache) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, this.pluginCache.updateProjectIncludes(this.projectConfig.input.include)];
+                                    case 2:
+                                        _a.sent();
+                                        _a.label = 3;
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        }); })];
                     case 1:
                         _a.sent();
                         return [2 /*return*/];
@@ -587,8 +601,9 @@ var AmxxBuilder = /** @class */ (function () {
         });
     };
     AmxxBuilder.prototype.initPluginCache = function () {
-        this.pluginCache = new plugins_cache_1.default();
+        this.pluginCache = new plugins_cache_1.default(process.cwd());
         this.pluginCache.load(config_1.default.cacheFile);
+        this.pluginCache.updateProjectIncludes(this.projectConfig.input.include);
     };
     AmxxBuilder.prototype.execPathFilter = function (filePath, filter) {
         return globule_1.default.isMatch(filter, filePath, {

package/lib/builder/plugins-cache.d.ts

@@ -1,16 +1,20 @@
 export declare enum CacheValueType {
     Source = "src",
-    Compiled = "compiled"
+    Compiled = "compiled",
+    Includes = "Includes"
 }
 export default class PluginsCache {
+    projectDir: string;
     private cache;
-    constructor();
+    constructor(projectDir: string);
     save(cacheFile: string): void;
     load(cacheFile: string): void;
     isPluginUpdated(srcPath: string, pluginPath: string): Promise<boolean>;
     updatePlugin(srcPath: string, pluginPath: string): Promise<void>;
+    updateProjectIncludes(includeDirs: string[]): Promise<void>;
     deletePlugin(srcPath: string): Promise<void>;
     getFileCacheKey(filePath: string, type: CacheValueType): string;
+    private createProjectIncludesHash;
     private createHash;
     private createFileHash;
 }

package/lib/builder/plugins-cache.js

@@ -41,15 +41,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheValueType = void 0;
 var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
 var crypto_1 = __importDefault(require("crypto"));
 var node_cache_1 = __importDefault(require("node-cache"));
+var create_dir_hash_1 = __importDefault(require("../utils/create-dir-hash"));
 var CacheValueType;
 (function (CacheValueType) {
     CacheValueType["Source"] = "src";
     CacheValueType["Compiled"] = "compiled";
+    CacheValueType["Includes"] = "Includes";
 })(CacheValueType = exports.CacheValueType || (exports.CacheValueType = {}));
 var PluginsCache = /** @class */ (function () {
-    function PluginsCache() {
+    function PluginsCache(projectDir) {
+        this.projectDir = projectDir;
         this.cache = new node_cache_1.default();
     }
     PluginsCache.prototype.save = function (cacheFile) {
@@ -64,7 +68,7 @@ var PluginsCache = /** @class */ (function () {
     };
     PluginsCache.prototype.isPluginUpdated = function (srcPath, pluginPath) {
         return __awaiter(this, void 0, void 0, function () {
-            var srcCachedHash, srcHash, pluginHash, pluginCachedHash;
+            var srcCachedHash, srcHash, pluginHash, pluginCachedHash, projectIncludeHash, includesHash;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -88,6 +92,11 @@ var PluginsCache = /** @class */ (function () {
                         if (pluginHash !== pluginCachedHash) {
                             return [2 /*return*/, false];
                         }
+                        projectIncludeHash = this.cache.get(this.getFileCacheKey('.', CacheValueType.Includes));
+                        includesHash = this.cache.get(this.getFileCacheKey(srcPath, CacheValueType.Includes));
+                        if (projectIncludeHash !== includesHash) {
+                            return [2 /*return*/, false];
+                        }
                         return [2 /*return*/, true];
                 }
             });
@@ -95,7 +104,7 @@ var PluginsCache = /** @class */ (function () {
     };
     PluginsCache.prototype.updatePlugin = function (srcPath, pluginPath) {
         return __awaiter(this, void 0, void 0, function () {
-            var srcHash, pluginHash;
+            var srcHash, pluginHash, includeHash;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.createFileHash(srcPath)];
@@ -106,6 +115,22 @@ var PluginsCache = /** @class */ (function () {
                     case 2:
                         pluginHash = _a.sent();
                         this.cache.set(this.getFileCacheKey(srcPath, CacheValueType.Compiled), pluginHash);
+                        includeHash = this.cache.get(this.getFileCacheKey('.', CacheValueType.Includes));
+                        this.cache.set(this.getFileCacheKey(srcPath, CacheValueType.Includes), includeHash);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PluginsCache.prototype.updateProjectIncludes = function (includeDirs) {
+        return __awaiter(this, void 0, void 0, function () {
+            var includeHash;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.createProjectIncludesHash(includeDirs)];
+                    case 1:
+                        includeHash = _a.sent();
+                        this.cache.set(this.getFileCacheKey('.', CacheValueType.Includes), includeHash);
                         return [2 /*return*/];
                 }
             });
@@ -116,12 +141,26 @@ var PluginsCache = /** @class */ (function () {
             return __generator(this, function (_a) {
                 this.cache.del(this.getFileCacheKey(srcPath, CacheValueType.Source));
                 this.cache.del(this.getFileCacheKey(srcPath, CacheValueType.Compiled));
+                this.cache.del(this.getFileCacheKey(srcPath, CacheValueType.Includes));
                 return [2 /*return*/];
             });
         });
     };
     PluginsCache.prototype.getFileCacheKey = function (filePath, type) {
-        return "".concat(filePath, "?").concat(type);
+        return this.createHash("".concat(this.projectDir, ":").concat(filePath, "?").concat(type));
+    };
+    PluginsCache.prototype.createProjectIncludesHash = function (includeDirs) {
+        return __awaiter(this, void 0, void 0, function () {
+            var includeHash;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, create_dir_hash_1.default)(includeDirs, function (p) { return !p.info.isFile() || path_1.default.parse(p.info.name).ext === '.inc'; })];
+                    case 1:
+                        includeHash = _a.sent();
+                        return [2 /*return*/, includeHash];
+                }
+            });
+        });
     };
     PluginsCache.prototype.createHash = function (data) {
         var hashSum = crypto_1.default.createHash('sha256');

package/lib/cli/controller.d.ts

@@ -21,6 +21,7 @@ declare class Controller {
         overwrite: boolean;
         include: string[];
     }): Promise<any>;
+    cleanCache(): Promise<void>;
 }
 declare const _default: Controller;
 export default _default;

package/lib/cli/controller.js

@@ -40,6 +40,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
 var lodash_1 = require("lodash");
 var builder_1 = __importDefault(require("../builder"));
 var compiler_1 = __importDefault(require("../downloaders/compiler"));
@@ -48,6 +49,7 @@ var project_creator_1 = __importDefault(require("./services/project-creator"));
 var template_builder_1 = __importDefault(require("./services/template-builder"));
 var project_config_1 = __importDefault(require("../project-config"));
 var logger_1 = __importDefault(require("../logger/logger"));
+var config_1 = __importDefault(require("../config"));
 var Controller = /** @class */ (function () {
     function Controller() {
     }
@@ -173,7 +175,9 @@ var Controller = /** @class */ (function () {
                         return [4 /*yield*/, (0, thirdparty_1.default)({
                                 name: dependency.name,
                                 url: dependency.url,
-                                dir: projectConfig.thirdparty.dir
+                                dir: projectConfig.thirdparty.dir,
+                                strip: dependency.strip,
+                                filter: dependency.filter
                             })];
                     case 4:
                         _b.sent();
@@ -240,6 +244,15 @@ var Controller = /** @class */ (function () {
             });
         });
     };
+    Controller.prototype.cleanCache = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                fs_1.default.promises.rm(config_1.default.cacheFile);
+                fs_1.default.promises.rm(config_1.default.downloadDir, { recursive: true, force: true });
+                return [2 /*return*/];
+            });
+        });
+    };
     return Controller;
 }());
 exports.default = new Controller();

package/lib/cli/program.js

@@ -140,6 +140,18 @@ program
         }
     });
 }); });
+program
+    .command('cache clean')
+    .action(function () { 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.cleanCache()];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
 program
     .command('generate')
     .alias('new')

package/lib/downloaders/thirdparty/downloader.js

@@ -42,6 +42,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var path_1 = __importDefault(require("path"));
 var mkdirp_1 = __importDefault(require("mkdirp"));
 var decompress_1 = __importDefault(require("decompress"));
+var globule_1 = __importDefault(require("globule"));
 var download_1 = __importDefault(require("../../utils/download"));
 var config_1 = __importDefault(require("../../config"));
 function downloadThirdparty(options) {
@@ -58,7 +59,14 @@ function downloadThirdparty(options) {
                     return [4 /*yield*/, (0, mkdirp_1.default)(outDir)];
                 case 2:
                     _a.sent();
-                    return [4 /*yield*/, (0, decompress_1.default)(filePath, outDir)];
+                    return [4 /*yield*/, (0, decompress_1.default)(filePath, outDir, {
+                            strip: options.strip,
+                            filter: options.filter && (function (file) { return globule_1.default.isMatch(options.filter, file.path, {
+                                dot: true,
+                                nocase: true,
+                                matchBase: true
+                            }); })
+                        })];
                 case 3:
                     _a.sent();
                     return [2 /*return*/];

package/lib/downloaders/thirdparty/types.d.ts

@@ -2,4 +2,6 @@ export interface IDownloadThirdpartyOptions {
     name: string;
     url: string;
     dir: string;
+    strip: number;
+    filter?: string | string[];
 }

package/lib/project-config/resolve.js

@@ -42,7 +42,8 @@ function resolve(overrides, projectDir) {
             dir: resolvePath(config.compiler.dir),
         },
         thirdparty: {
-            dir: resolvePath(config.thirdparty.dir)
+            dir: resolvePath(config.thirdparty.dir),
+            dependencies: (0, lodash_1.map)(config.thirdparty.dependencies, function (dependency) { return (__assign(__assign({}, dependency), { strip: dependency.strip || 0 })); })
         }
     });
     return resolvedConfig;

package/lib/types/index.d.ts

@@ -3,6 +3,12 @@ export interface IAssetInput {
     dest?: string;
     filter?: string | string[];
 }
+export interface IDependency {
+    name: string;
+    url: string;
+    strip?: number;
+    filter?: string | string[];
+}
 export interface IProjectConfig {
     input: {
         scripts: null | string | string[];
@@ -25,10 +31,7 @@ export interface IProjectConfig {
     };
     thirdparty: {
         dir: string | null;
-        dependencies: {
-            name: string;
-            url: string;
-        }[];
+        dependencies: IDependency[];
     };
     include: null | string[];
     rules: {
@@ -67,5 +70,8 @@ export interface IResolvedProjectConfig extends IProjectConfig {
     };
     thirdparty: IProjectConfig['thirdparty'] & {
         dir: string;
+        dependencies: (IDependency & {
+            strip: number;
+        })[];
     };
 }

package/lib/utils/create-dir-hash.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import fs from 'fs';
+import crypto from 'crypto';
+declare function createDirHash(dirs: string[], filterFn?: (p: {
+    dir: string;
+    info: fs.Dirent;
+}) => boolean, initialHash?: crypto.Hash): Promise<string>;
+export default createDirHash;

package/lib/utils/create-dir-hash.js

@@ -0,0 +1,97 @@
+"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 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+var crypto_1 = __importDefault(require("crypto"));
+function createDirHash(dirs, filterFn, initialHash) {
+    if (filterFn === void 0) { filterFn = null; }
+    if (initialHash === void 0) { initialHash = null; }
+    return __awaiter(this, void 0, void 0, function () {
+        var hashSum, _i, dirs_1, dir, items, _a, items_1, item, fullPath, fileStat, data;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    hashSum = initialHash || crypto_1.default.createHash('sha256');
+                    _i = 0, dirs_1 = dirs;
+                    _b.label = 1;
+                case 1:
+                    if (!(_i < dirs_1.length)) return [3 /*break*/, 8];
+                    dir = dirs_1[_i];
+                    if (!fs_1.default.existsSync(dir)) {
+                        return [3 /*break*/, 7];
+                    }
+                    return [4 /*yield*/, fs_1.default.promises.readdir(dir, { withFileTypes: true })];
+                case 2:
+                    items = _b.sent();
+                    _a = 0, items_1 = items;
+                    _b.label = 3;
+                case 3:
+                    if (!(_a < items_1.length)) return [3 /*break*/, 7];
+                    item = items_1[_a];
+                    fullPath = path_1.default.join(dir, item.name);
+                    if (filterFn && !filterFn({ dir: dir, info: item })) {
+                        return [3 /*break*/, 6];
+                    }
+                    if (!item.isFile()) return [3 /*break*/, 5];
+                    return [4 /*yield*/, fs_1.default.promises.stat(fullPath)];
+                case 4:
+                    fileStat = _b.sent();
+                    data = "".concat(fullPath, ":").concat(fileStat.size, ":").concat(fileStat.mtimeMs);
+                    hashSum.update(data);
+                    return [3 /*break*/, 6];
+                case 5:
+                    if (item.isDirectory()) {
+                        createDirHash([fullPath], filterFn, hashSum);
+                    }
+                    _b.label = 6;
+                case 6:
+                    _a++;
+                    return [3 /*break*/, 3];
+                case 7:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 8: return [2 /*return*/, hashSum.digest('hex')];
+            }
+        });
+    });
+}
+exports.default = createDirHash;

package/package.json

@@ -2,7 +2,7 @@
   "name": "amxxpack",
   "description": "AMXXPack",
   "author": "Hedgehog Fog",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "license": "MIT",
   "main": "lib/builder/index.js",
   "types": "lib/builder/index.d.ts",