@sasjs/utils 2.48.2 → 2.49.1

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,sDAAyB;AACzB,8CAAuB;AACvB,iCAAmC;AAEnC,gCAIgB;AAChB;;;;;;;;;;;;;GAaG;AAEI,IAAM,OAAO,GAAG,UAAO,UAAkB;;;oBACvC,qBAAM,UAAU,CAAC,UAAU,CAAC,EAAA;oBAAnC,sBAAO,SAA4B,EAAA;;;KACpC,CAAA;AAFY,QAAA,OAAO,WAEnB;AAED;;GAEG;AACH,SAAgB,aAAa,CAC3B,SAAuB,EACvB,aAAwC;IAExC,OAAO,cAAc,CAAC,SAAS,EAAE,aAAa,CAAC,CAAA;AACjD,CAAC;AALD,sCAKC;AAED,IAAM,cAAc,GAAG,UACrB,SAAuB,EACvB,aAAwC,EACxC,UAMC;;IAND,2BAAA,EAAA;QACE,IAAI,EAAE,SAAS,CAAC,IAAI;QACpB,YAAY,EAAE,SAAS,CAAC,YAAY;QACpC,YAAY,EAAE,SAAS,CAAC,YAAY;QACpC,MAAM,EAAE,KAAK;QACb,OAAO,EAAE,EAAE;KACZ;;QAED,KAAqB,IAAA,KAAA,SAAA,SAAS,CAAC,OAAO,CAAA,gBAAA,4BAAE;YAAnC,IAAM,MAAM,WAAA;YACf,IAAI,aAAa,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,MAAM,CAAC,IAAI,EAAE;gBACtD,IAAI,MAAM,CAAC,MAAM,EAAE;oBACjB,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;iBAChC;qBAAM;oBACL,IAAM,IAAI,GAAG,cAAc,CAAC,MAAsB,EAAE,aAAa,EAAE;wBACjE,IAAI,EAAE,MAAM,CAAC,IAAI;wBACjB,YAAY,EAAE,MAAM,CAAC,YAAY;wBACjC,YAAY,EAAE,MAAM,CAAC,YAAY;wBACjC,MAAM,EAAE,KAAK;wBACb,OAAO,EAAE,EAAE;qBACZ,CAAC,CAAA;oBACF,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;iBAC9B;aACF;SACF;;;;;;;;;IAED,OAAO,UAAU,CAAA;AACnB,CAAC,CAAA;AAED,IAAM,QAAQ,GAAG,UAAO,QAAgB;;;QAChC,WAAW,GAAG,kBAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAA;QAE7C,IAAI,WAAW,CAAC,MAAM,EAAE;YAChB,IAAI,GAAG,IAAA,mBAAU,EAAC,KAAK,CAAC,CAAA;YAC9B,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;YACxB,sBAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,EAAA;SACxC;;;KACF,CAAA;AAED,IAAM,UAAU,GAAG,UACjB,UAAkB,EAClB,cAAmC,EACnC,YAMC;IAPD,+BAAA,EAAA,2BAAmC;IACnC,6BAAA,EAAA;QACE,IAAI,EAAE,EAAE;QACR,YAAY,EAAE,UAAU;QACxB,YAAY,EAAE,IAAA,sBAAe,EAAC,cAAc,EAAE,UAAU,CAAC;QACzD,MAAM,EAAE,KAAK;QACb,OAAO,EAAE,EAAE;KACZ;;;;;;wBAEuB,qBAAM,IAAA,qCAA8B,EAC1D,UAAU,EACV,KAAK,CACN,EAAA;;oBAHK,eAAe,GAAG,SAGvB;oBACD,eAAe,CAAC,IAAI,EAAE,CAAA;oBAElB,gBAAgB,GAAG,EAAE,CAAA;oBAEnB,SAAS,GAAG,GAAG,CAAA;oBACZ,CAAC,GAAG,CAAC;;;yBAAE,CAAA,CAAC,GAAG,eAAe,CAAC,MAAM,CAAA;oBAElC,SAAS,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAA;;;;oBAClC,6BAAA,SAAA,SAAS,CAAA,CAAA;;;;oBAArB,QAAQ;oBACX,YAAY,GAAG,cAAI,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;oBAChD,qBAAM,IAAA,eAAQ,EAAC,YAAY,CAAC,EAAA;;yBAA5B,SAA4B,EAA5B,wBAA4B;oBACN,qBAAM,UAAU,CAAC,YAAY,EAAE,cAAc,CAAC,EAAA;;oBAAhE,eAAe,GAAG,SAA8C;oBACtE,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;oBAE1C,gBAAgB,IAAI,eAAe,CAAC,IAAI,CAAA;;wBAE3B,qBAAM,QAAQ,CAAC,YAAY,CAAC,EAAA;;oBAAnC,IAAI,GAAG,SAA4B;oBAEzC,IAAI,CAAC,IAAI;wBAAE,wBAAQ;oBAEnB,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC;wBACxB,IAAI,MAAA;wBACJ,YAAY,EAAE,YAAY;wBAC1B,YAAY,EAAE,IAAA,sBAAe,EAAC,cAAc,EAAE,YAAY,CAAC;wBAC3D,MAAM,EAAE,IAAI;qBACb,CAAC,CAAA;oBAEF,gBAAgB,IAAI,IAAI,CAAA;;;;;;;;;;;;;;;;;oBAI5B,IAAI,gBAAgB,KAAK,EAAE,EAAE;wBACrB,IAAI,GAAG,IAAA,mBAAU,EAAC,KAAK,CAAC,CAAA;wBAC9B,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAA;wBAC7B,gBAAgB,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAA;qBACpD;;;oBA9ByC,CAAC,IAAI,SAAS,CAAA;;;oBAiC1D,YAAY,CAAC,IAAI,GAAG,gBAAgB,CAAA;oBAEpC,sBAAO,YAAY,EAAA;;;;CACpB,CAAA"}

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,125 @@
+"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 utils_1 = require("../../utils");
+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, utils_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 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:
+                compiledCode = '';
+                _b.label = 1;
+            case 1:
+                _b.trys.push([1, 6, 7, 8]);
+                macros_1 = __values(macros), macros_1_1 = macros_1.next();
+                _b.label = 2;
+            case 2:
+                if (!!macros_1_1.done) return [3 /*break*/, 5];
+                macro = macros_1_1.value;
+                macroPath = path_1.default.join((0, utils_1.getMacrosPath)(), macro);
+                return [4 /*yield*/, (0, file_1.readFile)(macroPath)];
+            case 3:
+                macroContent = _b.sent();
+                compiledCode += macroContent + '\n';
+                _b.label = 4;
+            case 4:
+                macros_1_1 = macros_1.next();
+                return [3 /*break*/, 2];
+            case 5: return [3 /*break*/, 8];
+            case 6:
+                e_1_1 = _b.sent();
+                e_1 = { error: e_1_1 };
+                return [3 /*break*/, 8];
+            case 7:
+                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 8: 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,qCAAkD;AAClD,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;;;;;;gBACtD,YAAY,GAAG,EAAE,CAAA;;;;gBAED,WAAA,SAAA,MAAM,CAAA;;;;gBAAf,KAAK;gBACR,SAAS,GAAG,cAAI,CAAC,IAAI,CAAC,IAAA,qBAAa,GAAE,EAAE,KAAK,CAAC,CAAA;gBAC9B,qBAAM,IAAA,eAAQ,EAAC,SAAS,CAAC,EAAA;;gBAAxC,YAAY,GAAG,SAAyB;gBAE9C,YAAY,IAAI,YAAY,GAAG,IAAI,CAAA;;;;;;;;;;;;;;;;oBAGrC,sBAAO,YAAY,EAAA;;;KACpB,CAAA;AAXY,QAAA,qBAAqB,yBAWjC"}

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[];