@plasmicapp/cli 0.1.162

package/dist/utils/npm-utils.js

@@ -0,0 +1,215 @@
+"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.detectPackageManager = exports.installCommand = exports.installUpgrade = exports.findPackageJsonDir = exports.isCliGloballyInstalled = exports.findInstalledVersion = exports.warnLatest = exports.getParsedPackageJson = exports.checkEngineStrict = exports.getCliVersion = exports.getParsedCliPackageJson = void 0;
+const child_process_1 = require("child_process");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const latest_version_1 = __importDefault(require("latest-version"));
+const path_1 = __importDefault(require("path"));
+const semver_1 = __importDefault(require("semver"));
+const deps_1 = require("../deps");
+const file_utils_1 = require("./file-utils");
+const user_utils_1 = require("./user-utils");
+function getParsedCliPackageJson() {
+    const packageJson = findup_sync_1.default("package.json", { cwd: __dirname });
+    if (!packageJson) {
+        throw new Error(`Cannot find package.json in ancestors of ${__dirname}`);
+    }
+    return parsePackageJson(packageJson);
+}
+exports.getParsedCliPackageJson = getParsedCliPackageJson;
+function getCliVersion() {
+    const j = getParsedCliPackageJson();
+    return j.version;
+}
+exports.getCliVersion = getCliVersion;
+/**
+ * Call this to check if we match the engine policy
+ */
+function checkEngineStrict() {
+    var _a;
+    const pkg = getParsedCliPackageJson();
+    const minNodeVersion = (_a = pkg === null || pkg === void 0 ? void 0 : pkg.engines) === null || _a === void 0 ? void 0 : _a.node;
+    if (!!minNodeVersion && !semver_1.default.satisfies(process.version, minNodeVersion)) {
+        deps_1.logger.warn(`Plasmic only works on Node ${minNodeVersion}`);
+        return false;
+    }
+    return true;
+}
+exports.checkEngineStrict = checkEngineStrict;
+function getParsedPackageJson() {
+    const packageJson = findup_sync_1.default("package.json");
+    if (!packageJson) {
+        throw new Error(`Cannot find package.json`);
+    }
+    return parsePackageJson(packageJson);
+}
+exports.getParsedPackageJson = getParsedPackageJson;
+// @TODO: is this function still used?
+function warnLatest(context, pkg, baseDir, msgs, yes) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const check = yield checkVersion(context, pkg);
+        if (check.type === "up-to-date") {
+            return;
+        }
+        else if (check.type === "wrong-npm-registry") {
+            deps_1.logger.warn(`${msgs.requiredMsg()} Unable to find this package in your npm registry. Please update this dependency manually.`);
+            return;
+        }
+        if (yield user_utils_1.confirmWithUser(`${check.type === "not-installed"
+            ? msgs.requiredMsg()
+            : msgs.updateMsg(check.current, check.latest)}  Do you want to ${check.type === "not-installed" ? "add" : "update"} it now?`, yes)) {
+            installUpgrade(pkg, baseDir);
+        }
+    });
+}
+exports.warnLatest = warnLatest;
+function checkVersion(context, pkg) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Try to get the latest version from npm
+        let last = null;
+        try {
+            last = yield latest_version_1.default(pkg);
+        }
+        catch (e) {
+            // This is likely because .npmrc is set to a different registry
+            return { type: "wrong-npm-registry" };
+        }
+        const cur = findInstalledVersion(context, pkg);
+        if (!cur) {
+            return { type: "not-installed" };
+        }
+        if (semver_1.default.gt(last, cur)) {
+            return {
+                type: "obsolete",
+                latest: last,
+                current: cur,
+            };
+        }
+        return { type: "up-to-date" };
+    });
+}
+function findInstalledVersion(context, pkg) {
+    const filename = findInstalledPackageJsonFile(context, pkg);
+    if (filename) {
+        const json = parsePackageJson(filename);
+        if (json && json.name === pkg) {
+            return json.version;
+        }
+    }
+    return undefined;
+}
+exports.findInstalledVersion = findInstalledVersion;
+/**
+ * Detects if the cli is globally installed.  `rootDir` is the folder
+ * where plasmic.json is
+ */
+function isCliGloballyInstalled(rootDir) {
+    const packageJsonFile = findPackageJsonPath(rootDir);
+    if (!packageJsonFile) {
+        // We assume global, as instructions state global and we can't really
+        // do better
+        return true;
+    }
+    const installedDir = __dirname;
+    // Else, we assume it is local if the installedDir is a subfolder of
+    // the root project dir
+    return !installedDir.startsWith(path_1.default.dirname(packageJsonFile));
+}
+exports.isCliGloballyInstalled = isCliGloballyInstalled;
+function findPackageJsonPath(dir) {
+    return file_utils_1.findFile(dir, (f) => f === "package.json", {
+        traverseParents: true,
+    });
+}
+function findPackageJsonDir(rootDir) {
+    const filePath = findPackageJsonPath(rootDir);
+    return filePath ? path_1.default.dirname(filePath) : undefined;
+}
+exports.findPackageJsonDir = findPackageJsonDir;
+function findInstalledPackageJsonFile(context, pkg) {
+    const packageJsonPath = findPackageJsonPath(context.rootDir);
+    const rootDir = packageJsonPath
+        ? path_1.default.dirname(packageJsonPath)
+        : context.rootDir;
+    const files = fast_glob_1.default.sync(`${rootDir}/**/node_modules/${pkg}/package.json`);
+    return files.length > 0 ? files[0] : undefined;
+}
+function parsePackageJson(path) {
+    try {
+        return JSON.parse(file_utils_1.readFileText(path));
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+function installUpgrade(pkg, baseDir, opts = {}) {
+    const cmd = installCommand(pkg, baseDir, opts);
+    if (!process.env.QUIET) {
+        deps_1.logger.info(cmd);
+    }
+    const r = child_process_1.spawnSync(cmd, {
+        shell: true,
+        stdio: process.env.QUIET ? "ignore" : "inherit",
+        cwd: baseDir,
+    });
+    if (r.status === 0) {
+        if (!process.env.QUIET) {
+            deps_1.logger.info(`Successfully added ${pkg} dependency.`);
+        }
+        return true;
+    }
+    else {
+        deps_1.logger.warn(`Cannot add ${pkg} to your project dependencies. Please add it manually.`);
+        return false;
+    }
+}
+exports.installUpgrade = installUpgrade;
+function installCommand(pkg, baseDir, opts = {}) {
+    const mgr = detectPackageManager(baseDir);
+    if (mgr === "yarn") {
+        if (opts.global) {
+            return `yarn global add ${pkg}`;
+        }
+        else if (opts.dev) {
+            return `yarn add --dev --ignore-scripts -W ${pkg}`;
+        }
+        else {
+            return `yarn add --ignore-scripts -W ${pkg}`;
+        }
+    }
+    else {
+        if (opts.global) {
+            return `npm install -g ${pkg}`;
+        }
+        else if (opts.dev) {
+            return `npm install --save-dev --ignore-scripts ${pkg}`;
+        }
+        else {
+            return `npm install --ignore-scripts ${pkg}`;
+        }
+    }
+}
+exports.installCommand = installCommand;
+function detectPackageManager(baseDir) {
+    const yarnLock = findup_sync_1.default("yarn.lock", { cwd: baseDir });
+    if (yarnLock) {
+        return "yarn";
+    }
+    else {
+        return "npm";
+    }
+}
+exports.detectPackageManager = detectPackageManager;

package/dist/utils/prompts.d.ts

@@ -0,0 +1,6 @@
+export declare function askChoice<T>(question: {
+    message: string;
+    choices: T[];
+    defaultAnswer: T;
+    hidePrompt: boolean;
+}): T | Promise<T>;

package/dist/utils/prompts.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askChoice = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+function askChoice(question) {
+    if (question.hidePrompt) {
+        return question.defaultAnswer;
+    }
+    return inquirer_1.default
+        .prompt([
+        {
+            name: "answer",
+            type: "list",
+            message: question.message,
+            choices: question.choices,
+        },
+    ])
+        .then((answer) => answer.answer);
+}
+exports.askChoice = askChoice;

package/dist/utils/resolve-utils.d.ts

@@ -0,0 +1,13 @@
+import { SyncArgs } from "../actions/sync";
+import { ProjectVersionMeta, VersionResolution } from "../api";
+import { PlasmicContext } from "./config-utils";
+/**
+ * Checks the versionResolution with plasmic.json, plasmic.lock, and user prompts
+ * to compute which projects should be synced
+ * @param versionResolution
+ * @param context
+ */
+export declare function checkVersionResolution(versionResolution: VersionResolution, context: PlasmicContext, opts: SyncArgs): Promise<ProjectVersionMeta[]>;
+export declare function getDependencies(projectId: string, version: string, versionResolution: VersionResolution): {
+    [projectId: string]: string;
+} | undefined;

package/dist/utils/resolve-utils.js

@@ -0,0 +1,198 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDependencies = exports.checkVersionResolution = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const deps_1 = require("../deps");
+const config_utils_1 = require("./config-utils");
+const error_1 = require("./error");
+const lang_utils_1 = require("./lang-utils");
+const semver = __importStar(require("./semver"));
+const user_utils_1 = require("./user-utils");
+/**
+ * Starting at the root, do a BFS of the full dependency tree
+ * Because ProjectVersionMeta only stores the (projectId, version),
+ * we need to search for the full ProjectVersionMeta of dependencies from `available`
+ * @param root
+ * @param versionResolution
+ */
+function walkDependencyTree(root, available) {
+    const queue = [root];
+    const result = [];
+    const getMeta = (projectId, version) => {
+        const meta = available.find((m) => m.projectId === projectId && m.version === version);
+        if (!meta) {
+            throw new Error(`Cannot find projectId=${projectId}, version=${version} in the sync resolution results.`);
+        }
+        return meta;
+    };
+    while (queue.length > 0) {
+        const curr = lang_utils_1.ensure(queue.shift());
+        result.push(curr);
+        queue.push(...lodash_1.default.toPairs(curr.dependencies).map(([projectId, version]) => getMeta(projectId, version)));
+    }
+    return result;
+}
+/**
+ * For a given project, check if its compatible with plasmic.json, plasmic.lock, and user
+ * @param meta
+ * @param context
+ */
+function checkProjectMeta(meta, root, context, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const projectId = meta.projectId;
+        const projectName = meta.projectName;
+        const newVersion = meta.version;
+        // Checks newVersion against plasmic.lock
+        const checkVersionLock = () => __awaiter(this, void 0, void 0, function* () {
+            const projectLock = context.lock.projects.find((p) => p.projectId === projectId);
+            const versionOnDisk = projectLock === null || projectLock === void 0 ? void 0 : projectLock.version;
+            if (!versionOnDisk) {
+                // Always sync if we haven't seen sync'ed before
+                return true;
+            }
+            if (semver.isLatest(versionOnDisk) &&
+                semver.isLatest(newVersion) &&
+                meta !== root) {
+                // If this is a dependency (not root), and we're dealing with latest dep version
+                // just skip, it's confusing
+                deps_1.logger.warn(`'${root.projectName}' depends on ${projectName}@${newVersion}. To update this project, explicitly specify this project for sync. Skipping...`);
+                return false;
+            }
+            if (semver.isLatest(newVersion)) {
+                // Always sync when version set to "latest"
+                return true;
+            }
+            if (semver.isLatest(versionOnDisk)) {
+                // Explicitly allow downgrades from "latest" to published version
+                return true;
+            }
+            // At this point, we can assume newVersion is always X.Y.Z (not latest)
+            if (semver.eq(newVersion, versionOnDisk)) {
+                if (opts.force) {
+                    deps_1.logger.info(`Project '${projectName}'@${newVersion} is already up to date, but syncing anyway because --force is used`);
+                    return true;
+                }
+                else {
+                    deps_1.logger.info(`Project '${projectName}'@${newVersion} is already up to date; skipping. (To force an update, run again with "--force")`);
+                    return false;
+                }
+            }
+            if (semver.lt(newVersion, versionOnDisk)) {
+                meta === root
+                    ? deps_1.logger.warn(`The local version of '${projectName}' (${versionOnDisk}) is higher than requested version @${newVersion}. Plasmic does not support downgrading a project. You should consider updating the version range in ${config_utils_1.CONFIG_FILE_NAME}.`)
+                    : deps_1.logger.warn(`'${root.projectName}' uses '${projectName}'@${newVersion}, but your code has '${projectName}'@${versionOnDisk}. You should consider upgrading this dependency in Plasmic Studio.`);
+                return false;
+            }
+            if (semver.gt(newVersion, versionOnDisk)) {
+                if (meta === root) {
+                    return true;
+                }
+                else {
+                    deps_1.logger.info(`'${root.projectName}' uses '${projectName}'@${newVersion}, but your code has version ${versionOnDisk}`);
+                    return yield user_utils_1.confirmWithUser(`Do you want to upgrade '${projectName}' to ${newVersion}?`, opts.yes);
+                }
+            }
+            throw new Error(`Error comparing version=${newVersion} with the version found in plasmic.lock (${versionOnDisk}) for '${projectName}'`);
+        });
+        // Checks newVersion against plasmic.json
+        const checkVersionRange = () => __awaiter(this, void 0, void 0, function* () {
+            const projectConfig = context.config.projects.find((p) => p.projectId === projectId);
+            const versionRange = projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.version;
+            // If haven't seen this before
+            if (!versionRange) {
+                // Always sync down dependencies if it's the first time to avoid compile/fix-imports error
+                projectId !== root.projectId
+                    ? deps_1.logger.info(`'${root.projectName}' uses '${projectName}', which has never been synced before. We will also sync '${projectName}'@${newVersion}.`)
+                    : deps_1.logger.info(`'${projectName} has never been synced before. Syncing...'`);
+                return true;
+            }
+            // If satisfies range in plasmic.json
+            if (semver.satisfies(newVersion, versionRange)) {
+                deps_1.logger.info(`Updating project '${projectName}' to ${newVersion}`);
+                return true;
+            }
+            deps_1.logger.warn(`${projectName}@${newVersion} falls outside the range specified in ${config_utils_1.CONFIG_FILE_NAME} (${versionRange})\nTip: To avoid this warning in the future, update your ${config_utils_1.CONFIG_FILE_NAME}.`);
+            return yield user_utils_1.confirmWithUser("Do you want to force it?", opts.force || opts.yes, "n");
+        });
+        const projectIds = opts.projects.length > 0
+            ? opts.projects
+            : context.config.projects.map((p) => p.projectId);
+        if (projectIds.includes(projectId) && opts.force) {
+            // if --force is used, and this is in the list of projects to sync, then
+            // we should always sync it, even if nothing has changed
+            return true;
+        }
+        return (yield checkVersionLock()) && (yield checkVersionRange());
+    });
+}
+/**
+ * Checks the versionResolution with plasmic.json, plasmic.lock, and user prompts
+ * to compute which projects should be synced
+ * @param versionResolution
+ * @param context
+ */
+function checkVersionResolution(versionResolution, context, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Fail if there's nothing to sync
+        if (versionResolution.projects.length <= 0) {
+            throw new error_1.HandledError(`Found nothing to sync. Make sure the projectId and version values are valid in ${config_utils_1.CONFIG_FILE_NAME}.`);
+        }
+        const seen = [];
+        const result = [];
+        for (const root of versionResolution.projects) {
+            const queue = opts.nonRecursive
+                ? [root]
+                : walkDependencyTree(root, versionResolution.dependencies).reverse();
+            for (const m of queue) {
+                // If we haven't seen this yet
+                if (!seen.find((p) => p.projectId === m.projectId)) {
+                    if (yield checkProjectMeta(m, root, context, opts)) {
+                        result.push(m);
+                    }
+                    seen.push(m);
+                }
+            }
+        }
+        // Ignore repeats
+        return result;
+    });
+}
+exports.checkVersionResolution = checkVersionResolution;
+function getDependencies(projectId, version, versionResolution) {
+    var _a;
+    const filterFn = (m) => m.projectId === projectId && m.version === version;
+    const meta = (_a = versionResolution.projects.find(filterFn)) !== null && _a !== void 0 ? _a : versionResolution.dependencies.find(filterFn);
+    return meta === null || meta === void 0 ? void 0 : meta.dependencies;
+}
+exports.getDependencies = getDependencies;

package/dist/utils/semver.d.ts

@@ -0,0 +1,34 @@
+import * as semverlib from "semver";
+/**
+ * Wrap `semver` with support for understanding "latest"
+ * - "latest" is both a version and a range
+ * - "latest" range will match any valid version number
+ * - "latest" version will only match "latest" version range
+ **/
+export declare type Version = semverlib.SemVer | "latest";
+export declare const latestTag = "latest";
+export declare const isLatest: (v: string) => boolean;
+export declare const valid: (v: string) => string | null;
+export declare const inc: (v: string, release: semverlib.ReleaseType) => string | null;
+export declare const prerelease: (v: string) => readonly string[] | null;
+export declare const major: (v: string) => number | "latest";
+export declare const minor: (v: string) => number | "latest";
+export declare const patch: (v: string) => number | "latest";
+export declare const eq: (v1: string, v2: string) => boolean;
+export declare const gt: (v1: string, v2: string) => boolean;
+export declare const lt: (v1: string, v2: string) => boolean;
+export declare const validRange: (range: string) => string;
+export declare const satisfies: (v: string, range: string) => boolean;
+export declare const toTildeRange: (v: string) => string | null;
+export declare const toCaretRange: (v: string) => string | null;
+export declare const gte: (v1: string, v2: string) => boolean;
+export declare const lte: (v1: string, v2: string) => boolean;
+export declare const neq: (v1: string, v2: string) => boolean;
+export declare const sortAsc: (versions: string[]) => string[];
+export declare const sortDesc: (versions: string[]) => string[];
+export declare const minSatisfying: (versions: string[], range: string) => string | null;
+export declare const maxSatisfying: (versions: string[], range: string) => string | null;
+export declare const coerce: (v: string) => string | undefined;
+export declare const gtr: (version: string, range: string) => boolean;
+export declare const ltr: (version: string, range: string) => boolean;
+export declare const outside: (version: string, range: string, hilo?: ">" | "<" | undefined) => boolean;

package/dist/utils/semver.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outside = exports.ltr = exports.gtr = exports.coerce = exports.maxSatisfying = exports.minSatisfying = exports.sortDesc = exports.sortAsc = exports.neq = exports.lte = exports.gte = exports.toCaretRange = exports.toTildeRange = exports.satisfies = exports.validRange = exports.lt = exports.gt = exports.eq = exports.patch = exports.minor = exports.major = exports.prerelease = exports.inc = exports.valid = exports.isLatest = exports.latestTag = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const semverlib = __importStar(require("semver"));
+exports.latestTag = "latest";
+exports.isLatest = (v) => v === exports.latestTag;
+exports.valid = (v) => exports.isLatest(v) ? exports.latestTag : semverlib.valid(v);
+exports.inc = (v, release) => exports.isLatest(v) ? exports.latestTag : semverlib.inc(v, release);
+exports.prerelease = (v) => exports.isLatest(v) ? [] : semverlib.prerelease(v);
+exports.major = (v) => exports.isLatest(v) ? exports.latestTag : semverlib.major(v);
+exports.minor = (v) => exports.isLatest(v) ? exports.latestTag : semverlib.minor(v);
+exports.patch = (v) => exports.isLatest(v) ? exports.latestTag : semverlib.patch(v);
+exports.eq = (v1, v2) => (exports.isLatest(v1) && exports.isLatest(v2)) ||
+    (!exports.isLatest(v1) && !exports.isLatest(v2) && semverlib.eq(v1, v2));
+exports.gt = (v1, v2) => (exports.isLatest(v1) && !exports.isLatest(v2)) ||
+    (!exports.isLatest(v1) && !exports.isLatest(v2) && semverlib.gt(v1, v2));
+exports.lt = (v1, v2) => (!exports.isLatest(v1) && exports.isLatest(v2)) ||
+    (!exports.isLatest(v1) && !exports.isLatest(v2) && semverlib.lt(v1, v2));
+exports.validRange = (range) => exports.isLatest(range) ? exports.latestTag : semverlib.validRange(range);
+exports.satisfies = (v, range) => (exports.isLatest(range) && !!exports.valid(v)) ||
+    (!exports.isLatest(v) && !exports.isLatest(range) && semverlib.satisfies(v, range));
+exports.toTildeRange = (v) => exports.isLatest(v) ? exports.latestTag : !!semverlib.valid(v) ? "~" + v : null;
+exports.toCaretRange = (v) => exports.isLatest(v) ? exports.latestTag : !!semverlib.valid(v) ? "^" + v : null;
+exports.gte = (v1, v2) => exports.eq(v1, v2) || exports.gt(v1, v2);
+exports.lte = (v1, v2) => exports.eq(v1, v2) || exports.lt(v1, v2);
+exports.neq = (v1, v2) => !exports.eq(v1, v2);
+exports.sortAsc = (versions) => lodash_1.default.cloneDeep(versions).sort((v1, v2) => exports.gt(v1, v2) ? +1 : exports.eq(v1, v2) ? 0 : -1);
+exports.sortDesc = (versions) => exports.sortAsc(versions).reverse();
+exports.minSatisfying = (versions, range) => { var _a; return (_a = exports.sortAsc(versions).find((v) => exports.satisfies(v, range))) !== null && _a !== void 0 ? _a : null; };
+exports.maxSatisfying = (versions, range) => { var _a; return (_a = exports.sortDesc(versions).find((v) => exports.satisfies(v, range))) !== null && _a !== void 0 ? _a : null; };
+exports.coerce = (v) => { var _a; return exports.isLatest(v) ? exports.latestTag : (_a = semverlib.coerce(v)) === null || _a === void 0 ? void 0 : _a.version; };
+exports.gtr = (version, range) => (exports.isLatest(version) && !exports.isLatest(range)) ||
+    (!exports.isLatest(version) && !exports.isLatest(range) && semverlib.gtr(version, range));
+exports.ltr = (version, range) => (!exports.isLatest(version) && exports.isLatest(range)) ||
+    (!exports.isLatest(version) && !exports.isLatest(range) && semverlib.ltr(version, range));
+exports.outside = (version, range, hilo) => (hilo === ">" && exports.gtr(version, range)) ||
+    (hilo === "<" && exports.ltr(version, range)) ||
+    (!hilo && (exports.gtr(version, range) || exports.ltr(version, range)));

package/dist/utils/test-utils.d.ts

@@ -0,0 +1,22 @@
+import * as tmp from "tmp";
+import { AuthConfig, PlasmicConfig, PlasmicLoaderConfig } from "../utils/config-utils";
+export declare class TempRepo {
+    tmpDir: tmp.DirResult;
+    constructor();
+    destroy(): void;
+    resolveFile(relativePath: string): string;
+    readFile(relativePath: string): string;
+    writeFile(relativePath: string, data: string): void;
+    deleteFile(relativePath: string): void;
+    checkFile(relativePath: string): boolean;
+    getComponentFileContents(projectId: string, componentId: string): string | undefined;
+    plasmicAuthPath(): string;
+    writePlasmicAuth(json: AuthConfig): void;
+    deletePlasmicAuth(): void;
+    plasmicJsonPath(): string;
+    readPlasmicJson(): PlasmicConfig;
+    writePlasmicJson(json: PlasmicConfig): void;
+    deletePlasmicJson(): void;
+    plasmicLoaderJsonPath(): string;
+    readPlasmicLoaderJson(): PlasmicLoaderConfig;
+}