trm-core 2.2.3 → 3.0.0

package/dist/actions/install/setDevclass.js

@@ -0,0 +1,115 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDevclass = void 0;
+const logger_1 = require("../../logger");
+const systemConnector_1 = require("../../systemConnector");
+const commons_1 = require("../../commons");
+const Inquirer_1 = require("../../inquirer/Inquirer");
+const registry_1 = require("../../registry");
+function _validateDevclass(input, packagesNamespace) {
+    const sInput = input.trim().toUpperCase();
+    if (sInput.length > 30) {
+        return `Package name must not exceede 30 characters limit.`;
+    }
+    if (packagesNamespace.startsWith('/')) {
+        if (!sInput.startsWith(packagesNamespace)) {
+            return `Package name must use namespace "${packagesNamespace}".`;
+        }
+        else {
+            return true;
+        }
+    }
+    else {
+        return true;
+    }
+}
+exports.setDevclass = {
+    name: 'set-devclass',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const tdevc = context.runtime.tdevcData;
+        const keepOriginalPackages = context.parsedInput.keepOriginalPackages;
+        const packageName = context.parsedInput.packageName;
+        const registry = context.runtime.registry;
+        const forceDevclassInput = context.parsedInput.forceDevclassInput;
+        var packageReplacements = context.parsedInput.packageReplacements;
+        const originalPackageHierarchy = (0, commons_1.getPackageHierarchy)(tdevc);
+        if (keepOriginalPackages) {
+            packageReplacements = tdevc.map(o => {
+                return {
+                    originalDevclass: o.devclass,
+                    installDevclass: o.devclass
+                };
+            });
+        }
+        else {
+            if (packageReplacements.length < 0) {
+                packageReplacements = yield systemConnector_1.SystemConnector.getInstallPackages(packageName, registry);
+            }
+        }
+        var rootDevclass = (_a = packageReplacements.find(o => o.originalDevclass === originalPackageHierarchy.devclass)) === null || _a === void 0 ? void 0 : _a.installDevclass;
+        if (!rootDevclass) {
+            rootDevclass = originalPackageHierarchy.devclass;
+        }
+        const packagesNamespace = (0, commons_1.getPackageNamespace)(rootDevclass);
+        var inq1Prompts = [];
+        tdevc.forEach(t => {
+            const replacement = packageReplacements.find(o => o.originalDevclass === t.devclass);
+            if (!replacement || forceDevclassInput) {
+                if (context.parsedInput.noInquirer) {
+                    logger_1.Logger.error(`There's no replacement devclass for "${t.devclass}" and running in silent context: exit!`, true);
+                    throw new Error(`Can't continue install: running in silent and no action taken for devclass input`);
+                }
+                inq1Prompts.push({
+                    type: "input",
+                    name: t.devclass,
+                    default: t.devclass,
+                    message: `Input name for package "${t.devclass}"`,
+                    validate: (input) => {
+                        return _validateDevclass(input, packagesNamespace);
+                    }
+                });
+            }
+            else {
+                const devclassValid = _validateDevclass(replacement.installDevclass, packagesNamespace);
+                if (devclassValid !== true) {
+                    throw new Error(devclassValid);
+                }
+            }
+        });
+        if (inq1Prompts.length > 0) {
+            const inq1 = yield Inquirer_1.Inquirer.prompt(inq1Prompts);
+            Object.keys(inq1).forEach(k => {
+                packageReplacements = packageReplacements.filter(o => o.originalDevclass !== k);
+                packageReplacements.push({
+                    originalDevclass: k,
+                    installDevclass: inq1[k].trim().toUpperCase()
+                });
+            });
+        }
+        logger_1.Logger.loading(`Updating install packages...`);
+        var installDevc = [];
+        packageReplacements.forEach(o => {
+            installDevc.push({
+                package_name: packageName,
+                package_registry: registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? 'public' : registry.endpoint,
+                original_devclass: o.originalDevclass,
+                install_devclass: o.installDevclass
+            });
+        });
+        yield systemConnector_1.SystemConnector.setInstallDevc(installDevc);
+        context.runtime.originalPackageHierarchy = originalPackageHierarchy;
+        context.runtime.packageReplacements = packageReplacements;
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+    })
+};

package/dist/actions/install/setPackageIntegrity.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+export declare const setPackageIntegrity: Step<InstallWorkflowContext>;

package/dist/actions/install/setPackageIntegrity.js

@@ -0,0 +1,30 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPackageIntegrity = void 0;
+const logger_1 = require("../../logger");
+const systemConnector_1 = require("../../systemConnector");
+const registry_1 = require("../../registry");
+exports.setPackageIntegrity = {
+    name: 'set-package-integrity',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const packageName = context.parsedInput.packageName;
+        const registry = context.runtime.registry;
+        const packageRegistry = registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? 'public' : registry.endpoint;
+        const fetchedIntegrity = context.runtime.fetchedIntegrity;
+        logger_1.Logger.loading(`Finalizing install...`);
+        yield systemConnector_1.SystemConnector.setPackageIntegrity({
+            package_name: packageName,
+            package_registry: packageRegistry,
+            integrity: fetchedIntegrity
+        });
+    })
+};

package/dist/actions/install/setR3trans.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+export declare const setR3trans: Step<InstallWorkflowContext>;

package/dist/actions/install/setR3trans.js

@@ -0,0 +1,24 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setR3trans = void 0;
+const logger_1 = require("../../logger");
+const node_r3trans_1 = require("node-r3trans");
+exports.setR3trans = {
+    name: 'set-R3trans',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const options = context.parsedInput.r3transOptions;
+        const r3trans = new node_r3trans_1.R3trans(options);
+        const r3transVersion = yield r3trans.getVersion();
+        logger_1.Logger.info(r3transVersion);
+        context.runtime.r3trans = r3trans;
+    })
+};

package/dist/actions/install/setSystemPackages.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+export declare const setSystemPackages: Step<InstallWorkflowContext>;

package/dist/actions/install/setSystemPackages.js

@@ -0,0 +1,25 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSystemPackages = void 0;
+const systemConnector_1 = require("../../systemConnector");
+const logger_1 = require("../../logger");
+exports.setSystemPackages = {
+    name: 'set-system-packages',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var systemPackages = context.parsedInput.systemPackages;
+        if (systemPackages.length === 0) {
+            logger_1.Logger.loading(`Reading system packages`, true);
+            systemPackages = yield systemConnector_1.SystemConnector.getInstalledPackages(true);
+        }
+        context.parsedInput.systemPackages = systemPackages;
+    })
+};

package/dist/actions/installDependency/checkAlreadyInstalled.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallDependencyWorkflowContext } from ".";
+export declare const checkAlreadyInstalled: Step<InstallDependencyWorkflowContext>;

package/dist/actions/installDependency/checkAlreadyInstalled.js

@@ -0,0 +1,42 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAlreadyInstalled = void 0;
+const logger_1 = require("../../logger");
+const manifest_1 = require("../../manifest");
+exports.checkAlreadyInstalled = {
+    name: 'check-already-installed',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.parsedInput.forceInstall) {
+            logger_1.Logger.log(`Skipping already installed check (input)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const packageName = context.parsedInput.packageName;
+        const aPackages = context.runtime.releasePackages;
+        const installedPackages = context.parsedInput.systemPackages;
+        var alreadyInstalled = false;
+        aPackages.forEach(o => {
+            if (!alreadyInstalled) {
+                alreadyInstalled = installedPackages.find(ip => manifest_1.Manifest.compare(ip.manifest, o.manifest, true)) ? true : false;
+            }
+        });
+        if (alreadyInstalled) {
+            logger_1.Logger.info(`Dependency "${packageName}" already installed.`);
+            context.runtime.skipInstall = true;
+        }
+        context.runtime.skipInstall = alreadyInstalled;
+    })
+};

package/dist/actions/installDependency/findInstallRelease.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallDependencyWorkflowContext } from ".";
+export declare const findInstallRelease: Step<InstallDependencyWorkflowContext>;

package/dist/actions/installDependency/findInstallRelease.js

@@ -0,0 +1,59 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findInstallRelease = void 0;
+const logger_1 = require("../../logger");
+const semver_sort_1 = require("semver-sort");
+const crypto_1 = require("crypto");
+exports.findInstallRelease = {
+    name: 'find-install-release',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.skipInstall) {
+            logger_1.Logger.log(`Skipping find install release (skipInstall)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const packageName = context.parsedInput.packageName;
+        const releases = context.runtime.releases;
+        const aPackages = context.runtime.releasePackages;
+        const integrity = context.parsedInput.integrity;
+        var version;
+        const sortedVersions = (0, semver_sort_1.desc)(releases.map(o => o.version));
+        var aSortedPackages = [];
+        for (const v of sortedVersions) {
+            aSortedPackages = aSortedPackages.concat(aPackages.filter(o => o.manifest.get().version === v));
+        }
+        if (integrity) {
+            for (const oPackage of aSortedPackages) {
+                if (!version) {
+                    const oArtifact = yield oPackage.fetchRemoteArtifact(oPackage.manifest.get().version);
+                    const fetchedIntegrity = (0, crypto_1.createHash)("sha512").update(oArtifact.binary).digest("hex");
+                    if (integrity === fetchedIntegrity) {
+                        version = oPackage.manifest.get().version;
+                    }
+                }
+            }
+        }
+        else {
+            if (sortedVersions.length > 0) {
+                version = sortedVersions[0];
+            }
+        }
+        if (!version) {
+            throw new Error(`Couldn't find dependency "${packageName}" on registry. Try manual install.`);
+        }
+        context.output.version = version;
+    })
+};

package/dist/actions/installDependency/getRangeReleases.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallDependencyWorkflowContext } from ".";
+export declare const getRangeReleases: Step<InstallDependencyWorkflowContext>;

package/dist/actions/installDependency/getRangeReleases.js

@@ -0,0 +1,38 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRangeReleases = void 0;
+const manifest_1 = require("../../manifest");
+const registry_1 = require("../../registry");
+const trmPackage_1 = require("../../trmPackage");
+exports.getRangeReleases = {
+    name: 'get-range-releases',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const packageName = context.parsedInput.packageName;
+        const versionRange = context.parsedInput.versionRange;
+        const registry = context.runtime.registry;
+        const releases = yield registry.getReleases(packageName, versionRange);
+        if (releases.length === 0) {
+            throw new Error(`Package "${packageName}", release not found in range "${versionRange}"`);
+        }
+        context.runtime.releases = releases;
+        context.runtime.releasePackages = [];
+        releases.forEach(o => {
+            const dummyManifest = {
+                name: packageName,
+                version: o.version,
+                registry: registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? undefined : registry.endpoint
+            };
+            const oDummyManifest = new manifest_1.Manifest(dummyManifest);
+            context.runtime.releasePackages.push(new trmPackage_1.TrmPackage(packageName, registry, oDummyManifest));
+        });
+    })
+};

package/dist/actions/installDependency/index.d.ts

@@ -0,0 +1,39 @@
+import { Registry } from "../../registry";
+import { Release } from "trm-registry-types";
+import { TrmPackage } from "../../trmPackage";
+import { InstallActionInput, InstallActionOutput } from "../install";
+export type InstallDependencyActionInput = {
+    packageName: string;
+    versionRange: string;
+    registry: Registry;
+    installOptions: InstallActionInput;
+    forceInstall?: boolean;
+    integrity?: string;
+    systemPackages?: TrmPackage[];
+};
+type WorkflowParsedInput = {
+    packageName?: string;
+    versionRange?: string;
+    forceInstall?: boolean;
+    installOptions?: InstallActionInput;
+    integrity?: string;
+    systemPackages?: TrmPackage[];
+};
+type WorkflowRuntime = {
+    registry?: Registry;
+    releases?: Release[];
+    releasePackages?: TrmPackage[];
+    skipInstall?: boolean;
+};
+export type InstallDependencyActionOutput = {
+    version?: string;
+    installOutput?: InstallActionOutput;
+};
+export type InstallDependencyWorkflowContext = {
+    rawInput: InstallDependencyActionInput;
+    parsedInput: WorkflowParsedInput;
+    runtime: WorkflowRuntime;
+    output?: InstallDependencyActionOutput;
+};
+export declare function installDependency(inputData: InstallDependencyActionInput): Promise<InstallDependencyActionOutput>;
+export {};

package/dist/actions/installDependency/index.js

@@ -0,0 +1,46 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installDependency = void 0;
+const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
+const logger_1 = require("../../logger");
+const util_1 = require("util");
+const init_1 = require("./init");
+const getRangeReleases_1 = require("./getRangeReleases");
+const setSystemPackages_1 = require("./setSystemPackages");
+const checkAlreadyInstalled_1 = require("./checkAlreadyInstalled");
+const findInstallRelease_1 = require("./findInstallRelease");
+const installRelease_1 = require("./installRelease");
+const WORKFLOW_NAME = 'install-dependency';
+function installDependency(inputData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const workflow = [
+            init_1.init,
+            getRangeReleases_1.getRangeReleases,
+            setSystemPackages_1.setSystemPackages,
+            checkAlreadyInstalled_1.checkAlreadyInstalled,
+            findInstallRelease_1.findInstallRelease,
+            installRelease_1.installRelease
+        ];
+        logger_1.Logger.log(`Ready to execute workflow ${WORKFLOW_NAME}, input data: ${(0, util_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
+        const result = yield (0, sammarksworkflow_1.default)(WORKFLOW_NAME, workflow, {
+            rawInput: inputData,
+            parsedInput: {},
+            runtime: {}
+        });
+        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        return {};
+    });
+}
+exports.installDependency = installDependency;

package/dist/actions/installDependency/init.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallDependencyWorkflowContext } from ".";
+export declare const init: Step<InstallDependencyWorkflowContext>;

package/dist/actions/installDependency/init.js

@@ -0,0 +1,39 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+const commons_1 = require("../../commons");
+const semver_1 = require("semver");
+exports.init = {
+    name: 'init',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var packageName = context.rawInput.packageName;
+        var versionRange = context.rawInput.versionRange;
+        const registry = context.rawInput.registry;
+        packageName = (0, commons_1.parsePackageName)({
+            fullName: packageName
+        }).fullName;
+        versionRange = (0, semver_1.validRange)(versionRange);
+        if (!versionRange) {
+            throw new Error(`Dependency "${packageName}", invalid version range.`);
+        }
+        context.parsedInput.packageName = packageName;
+        context.parsedInput.versionRange = versionRange;
+        context.parsedInput.forceInstall = context.rawInput.forceInstall ? true : false;
+        context.parsedInput.integrity = context.rawInput.integrity;
+        context.parsedInput.installOptions = context.rawInput.installOptions || {
+            packageName,
+            registry
+        };
+        context.parsedInput.systemPackages = context.rawInput.systemPackages || [];
+        context.runtime.registry = registry;
+    })
+};

package/dist/actions/installDependency/installRelease.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallDependencyWorkflowContext } from ".";
+export declare const installRelease: Step<InstallDependencyWorkflowContext>;

package/dist/actions/installDependency/installRelease.js

@@ -0,0 +1,43 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installRelease = void 0;
+const logger_1 = require("../../logger");
+const install_1 = require("../install");
+const util_1 = require("util");
+const SUBWORKFLOW_NAME = 'install-dependency-sub-install';
+exports.installRelease = {
+    name: 'install-release',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.skipInstall) {
+            logger_1.Logger.log(`Skipping install release (skipInstall)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const packageName = context.parsedInput.packageName;
+        const version = context.output.version;
+        const registry = context.runtime.registry;
+        const integrity = context.parsedInput.integrity;
+        const installOptions = context.parsedInput.installOptions;
+        const inputData = Object.assign(Object.assign({}, installOptions), { packageName,
+            version,
+            integrity,
+            registry });
+        logger_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, util_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
+        const result = yield (0, install_1.install)(inputData);
+        logger_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        context.output.installOutput = result;
+    })
+};

package/dist/actions/installDependency/setSystemPackages.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallDependencyWorkflowContext } from ".";
+export declare const setSystemPackages: Step<InstallDependencyWorkflowContext>;

package/dist/actions/installDependency/setSystemPackages.js

@@ -0,0 +1,25 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSystemPackages = void 0;
+const systemConnector_1 = require("../../systemConnector");
+const logger_1 = require("../../logger");
+exports.setSystemPackages = {
+    name: 'set-system-packages',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var systemPackages = context.parsedInput.systemPackages;
+        if (systemPackages.length === 0) {
+            logger_1.Logger.loading(`Reading system packages`, true);
+            systemPackages = yield systemConnector_1.SystemConnector.getInstalledPackages(true);
+        }
+        context.parsedInput.systemPackages = systemPackages;
+    })
+};

package/dist/actions/publish/buildTrmPackageInstance.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { PublishWorkflowContext } from ".";
+export declare const buildTrmPackageInstance: Step<PublishWorkflowContext>;

package/dist/actions/publish/buildTrmPackageInstance.js

@@ -0,0 +1,22 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTrmPackageInstance = void 0;
+const manifest_1 = require("../../manifest");
+const trmPackage_1 = require("../../trmPackage");
+exports.buildTrmPackageInstance = {
+    name: 'build-trm-package-instance',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        context.runtime.manifest = manifest_1.Manifest.normalize(context.runtime.manifest, false);
+        const oManifest = new manifest_1.Manifest(context.runtime.manifest);
+        context.runtime.trmPackage = new trmPackage_1.TrmPackage(context.runtime.manifest.name, context.runtime.registry, oManifest);
+    })
+};

package/dist/actions/publish/checkPackageExistance.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { PublishWorkflowContext } from ".";
+export declare const checkPackageExistance: Step<PublishWorkflowContext>;

package/dist/actions/publish/checkPackageExistance.js

@@ -0,0 +1,27 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPackageExistance = void 0;
+const logger_1 = require("../../logger");
+exports.checkPackageExistance = {
+    name: 'check-package-existance',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const packageName = context.parsedInput.packageName;
+        logger_1.Logger.loading(`Checking package "${packageName}"...`);
+        if (yield context.runtime.dummyPackage.exists()) {
+            context.runtime.packageExistsOnRegistry = true;
+        }
+        else {
+            logger_1.Logger.info(`First time publishing "${context.parsedInput.packageName}". Congratulations!`);
+            context.runtime.packageExistsOnRegistry = false;
+        }
+    })
+};