@sasjs/utils 2.48.1 → 2.49.0

package/fs/generateCompileProgram.d.ts

@@ -0,0 +1 @@
+export declare const generateCompileProgram: (folderPath: string) => Promise<string>;

package/fs/generateCompileProgram.js

@@ -0,0 +1,154 @@
+"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 __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCompileProgram = void 0;
+var path_1 = __importDefault(require("path"));
+var file_1 = require("../file");
+var helper_1 = require("./internal/helper");
+var generateCompileProgram = function (folderPath) { return __awaiter(void 0, void 0, void 0, function () {
+    var compiledMacrosCode, initialProgramContent, folderCreationCode;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, helper_1.getCompiledMacrosCode)(['mf_mkdir.sas'])];
+            case 1:
+                compiledMacrosCode = _a.sent();
+                initialProgramContent = (0, helper_1.getInitialCode)();
+                return [4 /*yield*/, fileAndDirectoryCreationCode(folderPath)];
+            case 2:
+                folderCreationCode = _a.sent();
+                return [2 /*return*/, compiledMacrosCode + initialProgramContent + folderCreationCode];
+        }
+    });
+}); };
+exports.generateCompileProgram = generateCompileProgram;
+var fileAndDirectoryCreationCode = function (resourcePath, pathRelativeTo, resultCode) {
+    if (pathRelativeTo === void 0) { pathRelativeTo = resourcePath; }
+    if (resultCode === void 0) { resultCode = ''; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _a, files, files_1, files_1_1, file, e_1_1, subFolders, subFolders_1, subFolders_1_1, folder, folderPath, e_2_1;
+        var e_1, _b, e_2, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, (0, file_1.isFolder)(resourcePath)];
+                case 1:
+                    if (!!(_d.sent())) return [3 /*break*/, 3];
+                    _a = resultCode;
+                    return [4 /*yield*/, (0, helper_1.generateCodeForFileCreation)(resourcePath, pathRelativeTo)];
+                case 2:
+                    resultCode = _a + _d.sent();
+                    return [2 /*return*/, resultCode];
+                case 3: return [4 /*yield*/, (0, file_1.listFilesInFolder)(resourcePath)];
+                case 4:
+                    files = _d.sent();
+                    _d.label = 5;
+                case 5:
+                    _d.trys.push([5, 10, 11, 12]);
+                    files_1 = __values(files), files_1_1 = files_1.next();
+                    _d.label = 6;
+                case 6:
+                    if (!!files_1_1.done) return [3 /*break*/, 9];
+                    file = files_1_1.value;
+                    return [4 /*yield*/, fileAndDirectoryCreationCode(path_1.default.join(resourcePath, file), pathRelativeTo, resultCode)];
+                case 7:
+                    resultCode = _d.sent();
+                    _d.label = 8;
+                case 8:
+                    files_1_1 = files_1.next();
+                    return [3 /*break*/, 6];
+                case 9: return [3 /*break*/, 12];
+                case 10:
+                    e_1_1 = _d.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 12];
+                case 11:
+                    try {
+                        if (files_1_1 && !files_1_1.done && (_b = files_1.return)) _b.call(files_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 12: return [4 /*yield*/, (0, file_1.listSubFoldersInFolder)(resourcePath)];
+                case 13:
+                    subFolders = _d.sent();
+                    _d.label = 14;
+                case 14:
+                    _d.trys.push([14, 19, 20, 21]);
+                    subFolders_1 = __values(subFolders), subFolders_1_1 = subFolders_1.next();
+                    _d.label = 15;
+                case 15:
+                    if (!!subFolders_1_1.done) return [3 /*break*/, 18];
+                    folder = subFolders_1_1.value;
+                    folderPath = path_1.default.join(resourcePath, folder);
+                    resultCode = "".concat(resultCode, "\n%mf_mkdir(&fsTarget").concat(folderPath.replace(pathRelativeTo, ''), ")\n");
+                    return [4 /*yield*/, fileAndDirectoryCreationCode(folderPath, pathRelativeTo, resultCode)];
+                case 16:
+                    resultCode = _d.sent();
+                    _d.label = 17;
+                case 17:
+                    subFolders_1_1 = subFolders_1.next();
+                    return [3 /*break*/, 15];
+                case 18: return [3 /*break*/, 21];
+                case 19:
+                    e_2_1 = _d.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 21];
+                case 20:
+                    try {
+                        if (subFolders_1_1 && !subFolders_1_1.done && (_c = subFolders_1.return)) _c.call(subFolders_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 21: return [2 /*return*/, resultCode];
+            }
+        });
+    });
+};
+//# sourceMappingURL=generateCompileProgram.js.map

package/fs/generateCompileProgram.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateCompileProgram.js","sourceRoot":"","sources":["../../src/fs/generateCompileProgram.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,8CAAuB;AACvB,gCAA6E;AAC7E,4CAI0B;AAEnB,IAAM,sBAAsB,GAAG,UAAO,UAAkB;;;;oBAClC,qBAAM,IAAA,8BAAqB,EAAC,CAAC,cAAc,CAAC,CAAC,EAAA;;gBAAlE,kBAAkB,GAAG,SAA6C;gBAElE,qBAAqB,GAAG,IAAA,uBAAc,GAAE,CAAA;gBAEnB,qBAAM,4BAA4B,CAAC,UAAU,CAAC,EAAA;;gBAAnE,kBAAkB,GAAG,SAA8C;gBAEzE,sBAAO,kBAAkB,GAAG,qBAAqB,GAAG,kBAAkB,EAAA;;;KACvE,CAAA;AARY,QAAA,sBAAsB,0BAQlC;AAED,IAAM,4BAA4B,GAAG,UACnC,YAAoB,EACpB,cAAqC,EACrC,UAAuB;IADvB,+BAAA,EAAA,6BAAqC;IACrC,2BAAA,EAAA,eAAuB;;;;;;wBAEjB,qBAAM,IAAA,eAAQ,EAAC,YAAY,CAAC,EAAA;;yBAA9B,CAAC,CAAC,SAA4B,CAAC,EAA/B,wBAA+B;oBACjC,KAAA,UAAU,CAAA;oBAAI,qBAAM,IAAA,oCAA2B,EAC7C,YAAY,EACZ,cAAc,CACf,EAAA;;oBAHD,UAAU,GAAV,KAAc,SAGb,CAAA;oBACD,sBAAO,UAAU,EAAA;wBAGL,qBAAM,IAAA,wBAAiB,EAAC,YAAY,CAAC,EAAA;;oBAA7C,KAAK,GAAG,SAAqC;;;;oBAChC,UAAA,SAAA,KAAK,CAAA;;;;oBAAb,IAAI;oBACA,qBAAM,4BAA4B,CAC7C,cAAI,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,EAC7B,cAAc,EACd,UAAU,CACX,EAAA;;oBAJD,UAAU,GAAG,SAIZ,CAAA;;;;;;;;;;;;;;;;yBAGgB,qBAAM,IAAA,6BAAsB,EAAC,YAAY,CAAC,EAAA;;oBAAvD,UAAU,GAAG,SAA0C;;;;oBACxC,eAAA,SAAA,UAAU,CAAA;;;;oBAApB,MAAM;oBACT,UAAU,GAAG,cAAI,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,CAAA;oBAElD,UAAU,GAAG,UAAG,UAAU,kCACT,UAAU,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,QAC1D,CAAA;oBAEgB,qBAAM,4BAA4B,CAC7C,UAAU,EACV,cAAc,EACd,UAAU,CACX,EAAA;;oBAJD,UAAU,GAAG,SAIZ,CAAA;;;;;;;;;;;;;;;;yBAGH,sBAAO,UAAU,EAAA;;;;CAClB,CAAA"}

package/fs/hash.d.ts

@@ -0,0 +1,22 @@
+import { HashedFolder } from '../types';
+/**
+ * Hashes each file in each directory, and then hashes the hashes to create a hash for each directory also.
+ *
+ * Whilst files are hashed in their entirety, the logic for creating a folder hash is as follows:
+ *
+ * Sort the files and subfolders by name (case sensitive, uppercase then lower)
+ * Take the first 100 hashes, concatenate and hash
+ * Concatenate this hash with another 100 hashes and hash again
+ * Continue until the end of the folder. This is the folder hash
+ * If a folder contains other folders, start from the bottom of the tree - the folder hashes cascade upwards so you know immediately if there is a change in a sub/sub directory
+ * If the folder has no content (empty) then it is ignored. No hash created.
+ *
+ * @param {string} folderPath - absolute folder path
+ */
+export declare const getHash: (folderPath: string) => Promise<HashedFolder>;
+/**
+ * It returns a hashed folder tree that contains the local directory resources that are not synced with remote
+ */
+export declare function compareHashes(localHash: HashedFolder, remoteHashMap: {
+    [key: string]: string;
+}): HashedFolder;

package/fs/hash.js

@@ -0,0 +1,225 @@
+"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 __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareHashes = exports.getHash = void 0;
+var fs_extra_1 = __importDefault(require("fs-extra"));
+var path_1 = __importDefault(require("path"));
+var crypto_1 = require("crypto");
+var file_1 = require("../file");
+/**
+ * Hashes each file in each directory, and then hashes the hashes to create a hash for each directory also.
+ *
+ * Whilst files are hashed in their entirety, the logic for creating a folder hash is as follows:
+ *
+ * Sort the files and subfolders by name (case sensitive, uppercase then lower)
+ * Take the first 100 hashes, concatenate and hash
+ * Concatenate this hash with another 100 hashes and hash again
+ * Continue until the end of the folder. This is the folder hash
+ * If a folder contains other folders, start from the bottom of the tree - the folder hashes cascade upwards so you know immediately if there is a change in a sub/sub directory
+ * If the folder has no content (empty) then it is ignored. No hash created.
+ *
+ * @param {string} folderPath - absolute folder path
+ */
+var getHash = function (folderPath) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, hashFolder(folderPath)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+exports.getHash = getHash;
+/**
+ * It returns a hashed folder tree that contains the local directory resources that are not synced with remote
+ */
+function compareHashes(localHash, remoteHashMap) {
+    return hashDifference(localHash, remoteHashMap);
+}
+exports.compareHashes = compareHashes;
+var hashDifference = function (localHash, remoteHashMap, hashedDiff) {
+    var e_1, _a;
+    if (hashedDiff === void 0) { hashedDiff = {
+        hash: localHash.hash,
+        absolutePath: localHash.absolutePath,
+        relativePath: localHash.relativePath,
+        isFile: false,
+        members: []
+    }; }
+    try {
+        for (var _b = __values(localHash.members), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var member = _c.value;
+            if (remoteHashMap[member.relativePath] !== member.hash) {
+                if (member.isFile) {
+                    hashedDiff.members.push(member);
+                }
+                else {
+                    var diff = hashDifference(member, remoteHashMap, {
+                        hash: member.hash,
+                        absolutePath: member.absolutePath,
+                        relativePath: member.relativePath,
+                        isFile: false,
+                        members: []
+                    });
+                    hashedDiff.members.push(diff);
+                }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return hashedDiff;
+};
+var hashFile = function (filePath) { return __awaiter(void 0, void 0, void 0, function () {
+    var fileContent, hash;
+    return __generator(this, function (_a) {
+        fileContent = fs_extra_1.default.readFileSync(filePath);
+        if (fileContent.length) {
+            hash = (0, crypto_1.createHash)('md5');
+            hash.update(fileContent);
+            return [2 /*return*/, hash.digest('hex').toUpperCase()];
+        }
+        return [2 /*return*/];
+    });
+}); };
+var hashFolder = function (folderPath, pathRelativeTo, hashedFolder) {
+    if (pathRelativeTo === void 0) { pathRelativeTo = folderPath; }
+    if (hashedFolder === void 0) { hashedFolder = {
+        hash: '',
+        absolutePath: folderPath,
+        relativePath: (0, file_1.getRelativePath)(pathRelativeTo, folderPath),
+        isFile: false,
+        members: []
+    }; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var filesAndFolders, concatenatedHash, chunkSize, i, resources, resources_1, resources_1_1, resource, resourcePath, hashedSubFolder, hash, e_2_1, hash;
+        var e_2, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, (0, file_1.listFilesAndSubFoldersInFolder)(folderPath, false)];
+                case 1:
+                    filesAndFolders = _b.sent();
+                    filesAndFolders.sort();
+                    concatenatedHash = '';
+                    chunkSize = 100;
+                    i = 0;
+                    _b.label = 2;
+                case 2:
+                    if (!(i < filesAndFolders.length)) return [3 /*break*/, 15];
+                    resources = filesAndFolders.slice(i, i + chunkSize);
+                    _b.label = 3;
+                case 3:
+                    _b.trys.push([3, 11, 12, 13]);
+                    resources_1 = (e_2 = void 0, __values(resources)), resources_1_1 = resources_1.next();
+                    _b.label = 4;
+                case 4:
+                    if (!!resources_1_1.done) return [3 /*break*/, 10];
+                    resource = resources_1_1.value;
+                    resourcePath = path_1.default.join(folderPath, resource);
+                    return [4 /*yield*/, (0, file_1.isFolder)(resourcePath)];
+                case 5:
+                    if (!_b.sent()) return [3 /*break*/, 7];
+                    return [4 /*yield*/, hashFolder(resourcePath, pathRelativeTo)];
+                case 6:
+                    hashedSubFolder = _b.sent();
+                    hashedFolder.members.push(hashedSubFolder);
+                    concatenatedHash += hashedSubFolder.hash;
+                    return [3 /*break*/, 9];
+                case 7: return [4 /*yield*/, hashFile(resourcePath)];
+                case 8:
+                    hash = _b.sent();
+                    if (!hash)
+                        return [3 /*break*/, 9];
+                    hashedFolder.members.push({
+                        hash: hash,
+                        absolutePath: resourcePath,
+                        relativePath: (0, file_1.getRelativePath)(pathRelativeTo, resourcePath),
+                        isFile: true
+                    });
+                    concatenatedHash += hash;
+                    _b.label = 9;
+                case 9:
+                    resources_1_1 = resources_1.next();
+                    return [3 /*break*/, 4];
+                case 10: return [3 /*break*/, 13];
+                case 11:
+                    e_2_1 = _b.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 13];
+                case 12:
+                    try {
+                        if (resources_1_1 && !resources_1_1.done && (_a = resources_1.return)) _a.call(resources_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 13:
+                    if (concatenatedHash !== '') {
+                        hash = (0, crypto_1.createHash)('md5');
+                        hash.update(concatenatedHash);
+                        concatenatedHash = hash.digest('hex').toUpperCase();
+                    }
+                    _b.label = 14;
+                case 14:
+                    i += chunkSize;
+                    return [3 /*break*/, 2];
+                case 15:
+                    hashedFolder.hash = concatenatedHash;
+                    return [2 /*return*/, hashedFolder];
+            }
+        });
+    });
+};
+//# sourceMappingURL=hash.js.map

package/fs/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sourceRoot":"","sources":["../../src/fs/hash.ts"],"names":[],"mappings":"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"}

package/fs/index.d.ts

@@ -0,0 +1,3 @@
+export { getHash, compareHashes } from './hash';
+export { generateCompileProgram } from './generateCompileProgram';
+export { generateProgramToGetRemoteHash, generateProgramToSyncHashDiff, findResourcesNotPresentLocally } from './sync';

package/fs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findResourcesNotPresentLocally = exports.generateProgramToSyncHashDiff = exports.generateProgramToGetRemoteHash = exports.generateCompileProgram = exports.compareHashes = exports.getHash = void 0;
+var hash_1 = require("./hash");
+Object.defineProperty(exports, "getHash", { enumerable: true, get: function () { return hash_1.getHash; } });
+Object.defineProperty(exports, "compareHashes", { enumerable: true, get: function () { return hash_1.compareHashes; } });
+var generateCompileProgram_1 = require("./generateCompileProgram");
+Object.defineProperty(exports, "generateCompileProgram", { enumerable: true, get: function () { return generateCompileProgram_1.generateCompileProgram; } });
+var sync_1 = require("./sync");
+Object.defineProperty(exports, "generateProgramToGetRemoteHash", { enumerable: true, get: function () { return sync_1.generateProgramToGetRemoteHash; } });
+Object.defineProperty(exports, "generateProgramToSyncHashDiff", { enumerable: true, get: function () { return sync_1.generateProgramToSyncHashDiff; } });
+Object.defineProperty(exports, "findResourcesNotPresentLocally", { enumerable: true, get: function () { return sync_1.findResourcesNotPresentLocally; } });
+//# sourceMappingURL=index.js.map

package/fs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/fs/index.ts"],"names":[],"mappings":";;;AAAA,+BAA+C;AAAtC,+FAAA,OAAO,OAAA;AAAE,qGAAA,aAAa,OAAA;AAC/B,mEAAiE;AAAxD,gIAAA,sBAAsB,OAAA;AAC/B,+BAIe;AAHb,sHAAA,8BAA8B,OAAA;AAC9B,qHAAA,6BAA6B,OAAA;AAC7B,sHAAA,8BAA8B,OAAA"}

package/fs/internal/helper.d.ts

@@ -0,0 +1,4 @@
+export declare const generateCodeForFileCreation: (filePath: string, pathRelativeTo: string) => Promise<string>;
+export declare const chunkFileContent: (fileContent: string) => string;
+export declare const getInitialCode: () => string;
+export declare const getCompiledMacrosCode: (macros: string[]) => Promise<string>;

package/fs/internal/helper.js

@@ -0,0 +1,130 @@
+"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 __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompiledMacrosCode = exports.getInitialCode = exports.chunkFileContent = exports.generateCodeForFileCreation = void 0;
+var path_1 = __importDefault(require("path"));
+var getNodeModulePath_1 = require("../../utils/getNodeModulePath");
+var chunk_1 = require("../../utils/chunk");
+var file_1 = require("../../file");
+var generateCodeForFileCreation = function (filePath, pathRelativeTo) { return __awaiter(void 0, void 0, void 0, function () {
+    var base64EncodedFileContent, chunkedFileContent;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, file_1.base64EncodeFile)(filePath)];
+            case 1:
+                base64EncodedFileContent = _a.sent();
+                chunkedFileContent = (0, exports.chunkFileContent)(base64EncodedFileContent);
+                return [2 /*return*/, "\nfilename _in64 temp lrecl=99999999;\ndata _null_;\nfile _in64;\n".concat(chunkedFileContent, "\nrun;\n\nfilename _out64 \"&fsTarget").concat(filePath.replace(pathRelativeTo, ''), "\";\n\n/* convert from base64 */\ndata _null_;\nlength filein 8 fileout 8;\nfilein = fopen(\"_in64\",'I',4,'B');\nfileout = fopen(\"_out64\",'O',3,'B');\nchar= '20'x;\ndo while(fread(filein)=0);\n  length raw $4 ;\n  do i=1 to 4;\n    rc=fget(filein,char,1);\n    substr(raw,i,1)=char;\n  end;\n  rc = fput(fileout, input(raw,$base64X4.));\n  rc =fwrite(fileout);\nend;\nrc = fclose(filein);\nrc = fclose(fileout);\nrun;\n\nfilename _in64 clear;\nfilename _out64 clear;\n")];
+        }
+    });
+}); };
+exports.generateCodeForFileCreation = generateCodeForFileCreation;
+var chunkFileContent = function (fileContent) {
+    var chunkedLines = (0, chunk_1.chunk)(fileContent);
+    if (chunkedLines.length === 1) {
+        return " put '".concat(chunkedLines[0].split("'").join("''"), "';\n");
+    }
+    var combinedLines = '';
+    chunkedLines.forEach(function (chunkedLine, index) {
+        var text = " put '".concat(chunkedLine.split("'").join("''"), "'").concat(index !== chunkedLines.length - 1 ? '@;\n' : ';\n');
+        combinedLines += text;
+    });
+    return combinedLines;
+};
+exports.chunkFileContent = chunkFileContent;
+var getInitialCode = function () { return "%global fsTarget;\n%let compiled_fsTarget=%sysfunc(pathname(work));\n%let fsTarget=%sysfunc(coalescec(&fsTarget,&compiled_fsTarget));\noptions nobomfile;\n\n%mf_mkdir(&fsTarget)\n"; };
+exports.getInitialCode = getInitialCode;
+var getCompiledMacrosCode = function (macros) { return __awaiter(void 0, void 0, void 0, function () {
+    var sasjsCorePath, compiledCode, macros_1, macros_1_1, macro, macroPath, macroContent, e_1_1;
+    var e_1, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, (0, getNodeModulePath_1.getNodeModulePath)('@sasjs/core')];
+            case 1:
+                sasjsCorePath = _b.sent();
+                if (!sasjsCorePath)
+                    throw new Error('@sasjs/core could not be found');
+                compiledCode = '';
+                _b.label = 2;
+            case 2:
+                _b.trys.push([2, 7, 8, 9]);
+                macros_1 = __values(macros), macros_1_1 = macros_1.next();
+                _b.label = 3;
+            case 3:
+                if (!!macros_1_1.done) return [3 /*break*/, 6];
+                macro = macros_1_1.value;
+                macroPath = path_1.default.join(sasjsCorePath, 'base', macro);
+                return [4 /*yield*/, (0, file_1.readFile)(macroPath)];
+            case 4:
+                macroContent = _b.sent();
+                compiledCode += macroContent + '\n';
+                _b.label = 5;
+            case 5:
+                macros_1_1 = macros_1.next();
+                return [3 /*break*/, 3];
+            case 6: return [3 /*break*/, 9];
+            case 7:
+                e_1_1 = _b.sent();
+                e_1 = { error: e_1_1 };
+                return [3 /*break*/, 9];
+            case 8:
+                try {
+                    if (macros_1_1 && !macros_1_1.done && (_a = macros_1.return)) _a.call(macros_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+                return [7 /*endfinally*/];
+            case 9: return [2 /*return*/, compiledCode];
+        }
+    });
+}); };
+exports.getCompiledMacrosCode = getCompiledMacrosCode;
+//# sourceMappingURL=helper.js.map

package/fs/internal/helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.js","sourceRoot":"","sources":["../../../src/fs/internal/helper.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,8CAAuB;AACvB,mEAAiE;AACjE,2CAAyC;AACzC,mCAAuD;AAEhD,IAAM,2BAA2B,GAAG,UACzC,QAAgB,EAChB,cAAsB;;;;oBAEW,qBAAM,IAAA,uBAAgB,EAAC,QAAQ,CAAC,EAAA;;gBAA3D,wBAAwB,GAAG,SAAgC;gBAC3D,kBAAkB,GAAG,IAAA,wBAAgB,EAAC,wBAAwB,CAAC,CAAA;gBACrE,sBAAO,4EAIP,kBAAkB,kDAGQ,QAAQ,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,4dAuB/D,EAAA;;;KACA,CAAA;AArCY,QAAA,2BAA2B,+BAqCvC;AAEM,IAAM,gBAAgB,GAAG,UAAC,WAAmB;IAClD,IAAM,YAAY,GAAG,IAAA,aAAK,EAAC,WAAW,CAAC,CAAA;IAEvC,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;QAC7B,OAAO,gBAAS,YAAY,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,SAAM,CAAA;KAC5D;IAED,IAAI,aAAa,GAAG,EAAE,CAAA;IAEtB,YAAY,CAAC,OAAO,CAAC,UAAC,WAAW,EAAE,KAAK;QACtC,IAAM,IAAI,GAAG,gBAAS,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,cACrD,KAAK,KAAK,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAClD,CAAA;QAEF,aAAa,IAAI,IAAI,CAAA;IACvB,CAAC,CAAC,CAAA;IAEF,OAAO,aAAa,CAAA;AACtB,CAAC,CAAA;AAlBY,QAAA,gBAAgB,oBAkB5B;AAEM,IAAM,cAAc,GAAG,cAAM,OAAA,qLAMnC,EANmC,CAMnC,CAAA;AANY,QAAA,cAAc,kBAM1B;AAEM,IAAM,qBAAqB,GAAG,UAAO,MAAgB;;;;;oBACpC,qBAAM,IAAA,qCAAiB,EAAC,aAAa,CAAC,EAAA;;gBAAtD,aAAa,GAAG,SAAsC;gBAC5D,IAAI,CAAC,aAAa;oBAAE,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAA;gBAEjE,YAAY,GAAG,EAAE,CAAA;;;;gBAED,WAAA,SAAA,MAAM,CAAA;;;;gBAAf,KAAK;gBACR,SAAS,GAAG,cAAI,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,CAAC,CAAA;gBACpC,qBAAM,IAAA,eAAQ,EAAC,SAAS,CAAC,EAAA;;gBAAxC,YAAY,GAAG,SAAyB;gBAE9C,YAAY,IAAI,YAAY,GAAG,IAAI,CAAA;;;;;;;;;;;;;;;;oBAGrC,sBAAO,YAAY,EAAA;;;KACpB,CAAA;AAdY,QAAA,qBAAqB,yBAcjC"}

package/fs/sync.d.ts

@@ -0,0 +1,6 @@
+import { HashedFolder } from '../types';
+export declare const generateProgramToGetRemoteHash: (remotePath: string) => Promise<string>;
+export declare const generateProgramToSyncHashDiff: (hashedFolder: HashedFolder, remotePath: string) => Promise<string>;
+export declare const findResourcesNotPresentLocally: (localHash: HashedFolder, remoteHashMap: {
+    [key: string]: string;
+}) => string[];

package/fs/sync.js

@@ -0,0 +1,208 @@
+"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 __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+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.findResourcesNotPresentLocally = exports.generateProgramToSyncHashDiff = exports.generateProgramToGetRemoteHash = void 0;
+var path_1 = __importDefault(require("path"));
+var helper_1 = require("./internal/helper");
+var generateProgramToGetRemoteHash = function (remotePath) { return __awaiter(void 0, void 0, void 0, function () {
+    var compiledMacrosCode, codeForHashCreation, code;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, helper_1.getCompiledMacrosCode)([
+                    'mp_hashdirectory.sas',
+                    'mp_jsonout.sas'
+                ])];
+            case 1:
+                compiledMacrosCode = _a.sent();
+                codeForHashCreation = getCodeForHashCreation();
+                code = compiledMacrosCode + codeForHashCreation;
+                return [2 /*return*/, setTargetAtStart(code, remotePath)];
+        }
+    });
+}); };
+exports.generateProgramToGetRemoteHash = generateProgramToGetRemoteHash;
+var generateProgramToSyncHashDiff = function (hashedFolder, remotePath) { return __awaiter(void 0, void 0, void 0, function () {
+    var compiledMacrosCode, initialProgramContent, pathRelativeTo, folderCreationCode, codeForHashCreation, code;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, helper_1.getCompiledMacrosCode)([
+                    'mp_hashdirectory.sas',
+                    'mp_jsonout.sas',
+                    'mf_mkdir.sas'
+                ])];
+            case 1:
+                compiledMacrosCode = _a.sent();
+                initialProgramContent = (0, helper_1.getInitialCode)();
+                pathRelativeTo = hashedFolder.absolutePath.endsWith(path_1.default.sep)
+                    ? hashedFolder.absolutePath.slice(0, -1)
+                    : hashedFolder.absolutePath;
+                return [4 /*yield*/, generateCodeForFolderCreation(hashedFolder, pathRelativeTo)];
+            case 2:
+                folderCreationCode = _a.sent();
+                codeForHashCreation = getCodeForHashCreation();
+                code = compiledMacrosCode +
+                    initialProgramContent +
+                    folderCreationCode +
+                    codeForHashCreation;
+                return [2 /*return*/, setTargetAtStart(code, remotePath)];
+        }
+    });
+}); };
+exports.generateProgramToSyncHashDiff = generateProgramToSyncHashDiff;
+var findResourcesNotPresentLocally = function (localHash, remoteHashMap) {
+    var localHashedArray = convertHashFolderTreeToArray(localHash);
+    var remoteHashedArray = Object.keys(remoteHashMap);
+    return remoteHashedArray.filter(function (item) { return !localHashedArray.includes(item); });
+};
+exports.findResourcesNotPresentLocally = findResourcesNotPresentLocally;
+var generateCodeForFolderCreation = function (hashedFolder, pathRelativeTo, resultCode) {
+    if (resultCode === void 0) { resultCode = ''; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b, member, _c, e_1_1;
+        var e_1, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    _e.trys.push([0, 7, 8, 9]);
+                    _a = __values(hashedFolder.members), _b = _a.next();
+                    _e.label = 1;
+                case 1:
+                    if (!!_b.done) return [3 /*break*/, 6];
+                    member = _b.value;
+                    if (!member.isFile) return [3 /*break*/, 3];
+                    _c = resultCode;
+                    return [4 /*yield*/, (0, helper_1.generateCodeForFileCreation)(member.absolutePath, pathRelativeTo)];
+                case 2:
+                    resultCode = _c + _e.sent();
+                    return [3 /*break*/, 5];
+                case 3:
+                    resultCode += "%mf_mkdir(&fsTarget".concat(member.absolutePath.replace(pathRelativeTo, ''), ")\n");
+                    return [4 /*yield*/, generateCodeForFolderCreation(member, pathRelativeTo, resultCode)];
+                case 4:
+                    resultCode = _e.sent();
+                    _e.label = 5;
+                case 5:
+                    _b = _a.next();
+                    return [3 /*break*/, 1];
+                case 6: return [3 /*break*/, 9];
+                case 7:
+                    e_1_1 = _e.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 9];
+                case 8:
+                    try {
+                        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 9: return [2 /*return*/, resultCode];
+            }
+        });
+    });
+};
+var getCodeForHashCreation = function () {
+    return "/* Get Hashes */\n%mp_hashdirectory(&fsTarget,maxDepth=MAX,outds=work.hashes)\n\n/* Prepare Response JSON */\nfilename tmp temp;\n%mp_jsonout(OPEN,jref=tmp)\n%mp_jsonout(OBJ,hashes,fmt=N,jref=tmp)\n%mp_jsonout(CLOSE,jref=tmp)\n\n/* Print to Log */\ndata _null_;\n  retain eof;\n  infile tmp end=eof lrecl=10000;\n  if _n_=1 then putlog '>>weboutBEGIN<<';\n  input;\n  putlog _infile_;\n  if eof then putlog '>>weboutEND<<';\nrun;\n";
+};
+var setTargetAtStart = function (code, target) {
+    return "%let fsTarget=".concat(target, ";\n").concat(code);
+};
+/**
+ * convert hash folder tree to an array of relative paths,
+ * the returned array will be used to check the resources that are present on remote but not local
+ */
+var convertHashFolderTreeToArray = function (hashedFolder, array) {
+    var e_2, _a;
+    if (array === void 0) { array = []; }
+    if (hashedFolder.isFile)
+        return __spreadArray(__spreadArray([], __read(array), false), [hashedFolder.relativePath], false);
+    try {
+        for (var _b = __values(hashedFolder.members), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var member = _c.value;
+            array = convertHashFolderTreeToArray(member, array);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    array.push(hashedFolder.relativePath);
+    return array;
+};
+//# sourceMappingURL=sync.js.map

package/fs/sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.js","sourceRoot":"","sources":["../../src/fs/sync.ts"],"names":[],"mappings":"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"}

package/index.d.ts

@@ -8,3 +8,4 @@ export * from './time';
 export * from './types';
 export * from './utils';
 export * from './compileTree';
+export * from './fs';

package/index.js

@@ -20,4 +20,5 @@ __exportStar(require("./time"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./compileTree"), exports);
+__exportStar(require("./fs"), exports);
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yCAAsB;AACtB,yCAAsB;AACtB,8CAA2B;AAC3B,0CAAuB;AACvB,2CAAwB;AACxB,6CAA0B;AAC1B,yCAAsB;AACtB,0CAAuB;AACvB,0CAAuB;AACvB,gDAA6B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yCAAsB;AACtB,yCAAsB;AACtB,8CAA2B;AAC3B,0CAAuB;AACvB,2CAAwB;AACxB,6CAA0B;AAC1B,yCAAsB;AACtB,0CAAuB;AACvB,0CAAuB;AACvB,gDAA6B;AAC7B,uCAAoB"}

package/package.json

@@ -11,12 +11,13 @@
   },
   "typings": "./index.d.ts",
   "scripts": {
-    "preinstall": "node checkNodeVersion",
-    "prebuild": "node checkNodeVersion",
+    "nodeVersionMessage": "echo \u001b[33m make sure you are running node lts version \u001b[0m",
+    "preinstall": "npm run nodeVersionMessage",
+    "prebuild": "npm run nodeVersionMessage",
     "build": "rimraf build && tsc",
     "prepublishOnly": "cp -r ./build/* . && rm -rf ./build && rm -rf ./src && rm jest.config.js && rm tsconfig.json",
     "postpublish": "git clean -fd",
-    "package:lib": "npm run build && cp ./package.json ./checkNodeVersion.js build && cp README.md build && cd build && npm version \"5.0.0\" && npm pack",
+    "package:lib": "npm run build && cp ./package.json build && cp README.md build && cd build && npm version \"5.0.0\" && npm pack",
     "test": "jest --config=jest.config.js --coverage",
     "lint:fix": "npx prettier --write \"{src,test}/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\"",
     "lint": "npx prettier --check \"{src,test}/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\"",
@@ -33,7 +34,7 @@
   },
   "homepage": "https://github.com/sasjs/utils#readme",
   "devDependencies": {
-    "@sasjs/core": "3.10.0",
+    "@sasjs/core": "4.41.0",
     "@types/cli-table": "0.3.0",
     "@types/find": "0.2.1",
     "@types/jest": "27.4.0",
@@ -60,5 +61,5 @@
     "rimraf": "3.0.2",
     "valid-url": "1.0.9"
   },
-  "version": "2.48.1"
+  "version": "2.49.0"
 }

package/types/hash.d.ts

@@ -0,0 +1,9 @@
+export interface HashedFile {
+    hash: string;
+    absolutePath: string;
+    relativePath: string;
+    isFile: boolean;
+}
+export interface HashedFolder extends HashedFile {
+    members: (HashedFile | HashedFolder)[];
+}

package/types/hash.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=hash.js.map

package/types/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sourceRoot":"","sources":["../../src/types/hash.ts"],"names":[],"mappings":""}

package/types/index.d.ts

@@ -3,6 +3,7 @@ export * from './configuration';
 export * from './decodedToken';
 export * from './extraResponseAttributes';
 export * from './fileTree';
+export * from './hash';
 export * from './httpsAgentOptions';
 export * from './macro';
 export * from './sasAuthResponse';

package/types/index.js

@@ -15,6 +15,7 @@ __exportStar(require("./configuration"), exports);
 __exportStar(require("./decodedToken"), exports);
 __exportStar(require("./extraResponseAttributes"), exports);
 __exportStar(require("./fileTree"), exports);
+__exportStar(require("./hash"), exports);
 __exportStar(require("./httpsAgentOptions"), exports);
 __exportStar(require("./macro"), exports);
 __exportStar(require("./sasAuthResponse"), exports);

package/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAAwB;AACxB,kDAA+B;AAC/B,iDAA8B;AAC9B,4DAAyC;AACzC,6CAA0B;AAC1B,sDAAmC;AACnC,0CAAuB;AACvB,oDAAiC;AACjC,kDAA+B;AAC/B,gDAA6B;AAC7B,+CAA4B;AAC5B,gDAA6B;AAC7B,2CAAwB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAAwB;AACxB,kDAA+B;AAC/B,iDAA8B;AAC9B,4DAAyC;AACzC,6CAA0B;AAC1B,yCAAsB;AACtB,sDAAmC;AACnC,0CAAuB;AACvB,oDAAiC;AACjC,kDAA+B;AAC/B,gDAA6B;AAC7B,+CAA4B;AAC5B,gDAA6B;AAC7B,2CAAwB"}

package/utils/getNodeModulePath.d.ts

@@ -0,0 +1,2 @@
+export declare const getNodeModulePath: (module: string) => Promise<string>;
+export declare const getGlobalNodeModulesPath: () => string;

package/utils/getNodeModulePath.js

@@ -0,0 +1,83 @@
+"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 });
+exports.getGlobalNodeModulesPath = exports.getNodeModulePath = void 0;
+var path_1 = __importDefault(require("path"));
+var child_process_1 = require("child_process");
+var file_1 = require("../file");
+var getNodeModulePath = function (module) { return __awaiter(void 0, void 0, void 0, function () {
+    var projectPath, utilsDepsPath, utilsLocalPath, utilsGlobalPath;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                projectPath = path_1.default.join(process.cwd(), 'node_modules', module);
+                return [4 /*yield*/, (0, file_1.folderExists)(projectPath)];
+            case 1:
+                if (_a.sent())
+                    return [2 /*return*/, projectPath
+                        // Check if module is present in @sasjs/utils located in project's dependencies
+                    ];
+                utilsDepsPath = path_1.default.join('@sasjs', 'utils', 'node_modules');
+                utilsLocalPath = path_1.default.join(process.cwd(), 'node_modules', utilsDepsPath, module);
+                return [4 /*yield*/, (0, file_1.folderExists)(utilsLocalPath)];
+            case 2:
+                if (_a.sent())
+                    return [2 /*return*/, utilsLocalPath
+                        // Check if module is present in global @sasjs/utils
+                    ];
+                utilsGlobalPath = path_1.default.join((0, exports.getGlobalNodeModulesPath)(), utilsDepsPath, module);
+                return [4 /*yield*/, (0, file_1.folderExists)(utilsGlobalPath)];
+            case 3:
+                if (_a.sent())
+                    return [2 /*return*/, utilsGlobalPath
+                        // Return default value
+                    ];
+                // Return default value
+                return [2 /*return*/, ''];
+        }
+    });
+}); };
+exports.getNodeModulePath = getNodeModulePath;
+var getGlobalNodeModulesPath = function () {
+    return (0, child_process_1.execSync)("npm root -g").toString().replace(/\n/, '');
+};
+exports.getGlobalNodeModulesPath = getGlobalNodeModulesPath;
+//# sourceMappingURL=getNodeModulePath.js.map

package/utils/getNodeModulePath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getNodeModulePath.js","sourceRoot":"","sources":["../../src/utils/getNodeModulePath.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,8CAAuB;AACvB,+CAAwC;AACxC,gCAAsC;AAE/B,IAAM,iBAAiB,GAAG,UAAO,MAAc;;;;;gBAE9C,WAAW,GAAG,cAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,cAAc,EAAE,MAAM,CAAC,CAAA;gBAEhE,qBAAM,IAAA,mBAAY,EAAC,WAAW,CAAC,EAAA;;gBAAnC,IAAI,SAA+B;oBAAE,sBAAO,WAAW;wBAEvD,+EAA+E;sBAFxB;gBAGjD,aAAa,GAAG,cAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,cAAc,CAAC,CAAA;gBAC5D,cAAc,GAAG,cAAI,CAAC,IAAI,CAC9B,OAAO,CAAC,GAAG,EAAE,EACb,cAAc,EACd,aAAa,EACb,MAAM,CACP,CAAA;gBAEG,qBAAM,IAAA,mBAAY,EAAC,cAAc,CAAC,EAAA;;gBAAtC,IAAI,SAAkC;oBAAE,sBAAO,cAAc;wBAE7D,oDAAoD;sBAFS;gBAGvD,eAAe,GAAG,cAAI,CAAC,IAAI,CAC/B,IAAA,gCAAwB,GAAE,EAC1B,aAAa,EACb,MAAM,CACP,CAAA;gBAEG,qBAAM,IAAA,mBAAY,EAAC,eAAe,CAAC,EAAA;;gBAAvC,IAAI,SAAmC;oBAAE,sBAAO,eAAe;wBAE/D,uBAAuB;sBAFwC;gBAE/D,uBAAuB;gBACvB,sBAAO,EAAE,EAAA;;;KACV,CAAA;AA5BY,QAAA,iBAAiB,qBA4B7B;AAEM,IAAM,wBAAwB,GAAG;IACtC,OAAA,IAAA,wBAAQ,EAAC,aAAa,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;AAApD,CAAoD,CAAA;AADzC,QAAA,wBAAwB,4BACiB"}

package/utils/index.d.ts

@@ -6,3 +6,4 @@ export { getExecutorPath } from './executor';
 export { bytesToSize } from './bytesToSize';
 export { diff } from './diff';
 export { chunk } from './chunk';
+export { getNodeModulePath } from './getNodeModulePath';

package/utils/index.js

@@ -10,7 +10,7 @@ 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);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.chunk = exports.diff = exports.bytesToSize = exports.getExecutorPath = exports.decodeFromBase64 = exports.encodeToBase64 = exports.urlOrigin = exports.escapeWinSlashes = exports.isLinux = exports.isWindows = exports.uniqArray = exports.asyncForEach = exports.uuidv4 = void 0;
+exports.getNodeModulePath = exports.chunk = exports.diff = exports.bytesToSize = exports.getExecutorPath = exports.decodeFromBase64 = exports.encodeToBase64 = exports.urlOrigin = exports.escapeWinSlashes = exports.isLinux = exports.isWindows = exports.uniqArray = exports.asyncForEach = exports.uuidv4 = void 0;
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "uuidv4", { enumerable: true, get: function () { return utils_1.uuidv4; } });
 Object.defineProperty(exports, "asyncForEach", { enumerable: true, get: function () { return utils_1.asyncForEach; } });
@@ -32,4 +32,6 @@ var diff_1 = require("./diff");
 Object.defineProperty(exports, "diff", { enumerable: true, get: function () { return diff_1.diff; } });
 var chunk_1 = require("./chunk");
 Object.defineProperty(exports, "chunk", { enumerable: true, get: function () { return chunk_1.chunk; } });
+var getNodeModulePath_1 = require("./getNodeModulePath");
+Object.defineProperty(exports, "getNodeModulePath", { enumerable: true, get: function () { return getNodeModulePath_1.getNodeModulePath; } });
 //# sourceMappingURL=index.js.map

package/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,iCAOgB;AANd,+FAAA,MAAM,OAAA;AACN,qGAAA,YAAY,OAAA;AACZ,kGAAA,SAAS,OAAA;AACT,kGAAA,SAAS,OAAA;AACT,gGAAA,OAAO,OAAA;AACP,yGAAA,gBAAgB,OAAA;AAElB,6CAA0B;AAE1B,6BAAiC;AAAxB,gGAAA,SAAS,OAAA;AAElB,mCAA2D;AAAlD,wGAAA,cAAc,OAAA;AAAE,0GAAA,gBAAgB,OAAA;AAEzC,uCAA4C;AAAnC,2GAAA,eAAe,OAAA;AAExB,6CAA2C;AAAlC,0GAAA,WAAW,OAAA;AACpB,+BAA6B;AAApB,4FAAA,IAAI,OAAA;AACb,iCAA+B;AAAtB,8FAAA,KAAK,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,iCAOgB;AANd,+FAAA,MAAM,OAAA;AACN,qGAAA,YAAY,OAAA;AACZ,kGAAA,SAAS,OAAA;AACT,kGAAA,SAAS,OAAA;AACT,gGAAA,OAAO,OAAA;AACP,yGAAA,gBAAgB,OAAA;AAElB,6CAA0B;AAE1B,6BAAiC;AAAxB,gGAAA,SAAS,OAAA;AAElB,mCAA2D;AAAlD,wGAAA,cAAc,OAAA;AAAE,0GAAA,gBAAgB,OAAA;AAEzC,uCAA4C;AAAnC,2GAAA,eAAe,OAAA;AAExB,6CAA2C;AAAlC,0GAAA,WAAW,OAAA;AACpB,+BAA6B;AAApB,4FAAA,IAAI,OAAA;AACb,iCAA+B;AAAtB,8FAAA,KAAK,OAAA;AACd,yDAAuD;AAA9C,sHAAA,iBAAiB,OAAA"}