zarro 1.173.2 → 1.173.4

package/gulp-tasks/modules/cache.js

@@ -0,0 +1,114 @@
+"use strict";
+(function () {
+    class CacheItem {
+        constructor(value, expires) {
+            this.value = value;
+            this.expires = expires;
+        }
+    }
+    class Cache {
+        constructor() {
+            this._store = {};
+        }
+        /**
+         * reads a value from the cache
+         * if the value is not found, the fallback, if supplied
+         * is returned, otherwise undefined is returned
+         * @param key
+         * @param fallback
+         */
+        read(key, fallback) {
+            const cached = this._findCacheItem(key);
+            return cached === undefined
+                ? fallback
+                : cached.value;
+        }
+        /**
+         * clears all cached values
+         */
+        clear() {
+            this._store = {};
+        }
+        /**
+         * stores a value in the cache
+         * @param key
+         * @param value
+         * @param ttlSeconds
+         */
+        write(key, value, ttlSeconds) {
+            this._store[key] = new CacheItem(value, Date.now() + ttlSeconds);
+        }
+        /**
+         * Runs the generator if there is no cache item with
+         * the provided key and stores the result. Subsequent
+         * calls will skip the generator function to retrieve
+         * from cache until the item expires.
+         * @param key
+         * @param generator
+         * @param ttlSeconds
+         */
+        async through(key, generator, ttlSeconds) {
+            const cached = this._findCacheItem(key);
+            if (cached) {
+                return cached.value;
+            }
+            const result = await generator();
+            this.write(key, result, ttlSeconds);
+            return result;
+        }
+        /**
+         * Runs the generator if there is no cache item with
+         * the provided key and stores the result. Subsequent
+         * calls will skip the generator function to retrieve
+         * from cache until the item expires.
+         * @param key
+         * @param generator
+         * @param ttlSeconds
+         */
+        throughSync(key, generator, ttlSeconds) {
+            const cached = this._findCacheItem(key);
+            if (cached) {
+                return cached.value;
+            }
+            const result = generator();
+            this.write(key, result, ttlSeconds);
+            return result;
+        }
+        _findCacheItem(key) {
+            const result = this._store[key];
+            if (result === undefined) {
+                return undefined;
+            }
+            if (result.expires < Date.now()) {
+                this.forget(key);
+                return undefined;
+            }
+            return result;
+        }
+        /**
+         * creates a new empty cache
+         */
+        create() {
+            return new Cache();
+        }
+        /**
+         * trims expired items from the cache
+         */
+        trim() {
+            for (const key of Object.keys(this._store)) {
+                const item = this._store[key];
+                if (item.expires < Date.now()) {
+                    this.forget(key);
+                }
+            }
+        }
+        /**
+         * forgets the cached item by key
+         * @param key
+         */
+        forget(key) {
+            delete this._store[key];
+        }
+    }
+    module.exports = new Cache();
+})();

package/gulp-tasks/modules/dotnet-cli.js

@@ -18,6 +18,7 @@
     const env = requireModule("env");
     const Version = requireModule("version");
     const SystemError = requireModule("system-error");
+    const cache = requireModule("cache");
     const emojiLabels = {
         testing: `🧪 Testing`,
         packing: `📦 Packing`,
@@ -787,6 +788,13 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
         const opts = typeof options === "string"
             ? { search: options }
             : options;
+        if (opts.skipCache) {
+            return await searchPackages(opts);
+        }
+        return await cache.through(JSON.stringify(opts), async () => await searchPackagesUncached(opts), 60 // cache for a minute
+        );
+    }
+    async function searchPackagesUncached(opts) {
         const args = ["package", "search"];
         pushIfSet(args, opts.source, "--source");
         pushFlag(args, opts.exactMatch, "--exact-match");
@@ -963,12 +971,19 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
         return source;
     }
     async function upgradePackages(opts) {
-        var _a;
         verifyExists(opts, "no options provided to upgradePackages");
         verifyNonEmptyString(opts.pathToProjectOrSolution, "no path to a project or solution was supplied");
         if (!opts.packages || opts.packages.length === 0) {
             throw new ZarroError(`no packages were specified`);
         }
+        if (opts.showProgress === undefined) {
+            opts.showProgress = true;
+        }
+        const { ExecStepContext, Labelers } = require("exec-step"), ctx = new ExecStepContext({
+            labeler: opts.showProgress
+                ? Labelers.interactive
+                : Labelers.none
+        });
         const projects = isProject(opts.pathToProjectOrSolution)
             ? [opts.pathToProjectOrSolution]
             : await listProjects(opts.pathToProjectOrSolution);
@@ -985,16 +1000,22 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
                     }
                 }
             }
-            const upstream = await searchForMultiplePackages(toUpgrade, opts.source, (_a = opts.preRelease) !== null && _a !== void 0 ? _a : false);
+            if (toUpgrade.length === 0) {
+            }
+            const message = `searching for ${toUpgrade.length} packages to upgrade in ${project}`;
+            const upstream = await ctx.exec(message, async () => {
+                var _a;
+                return await searchForMultiplePackages(toUpgrade, opts.source, (_a = opts.preRelease) !== null && _a !== void 0 ? _a : false);
+            });
             for (const pkg of upstream) {
-                await installPackage({
+                await ctx.exec(`installing '${pkg.id}' at version '${pkg.version}' into '${project}'`, async () => await installPackage({
                     projectFile: project,
                     id: pkg.id,
                     version: pkg.version.toString(),
                     source: opts.source,
                     noRestore: opts.noRestore,
                     preRelease: opts.preRelease
-                });
+                }));
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zarro",
-  "version": "1.173.2",
+  "version": "1.173.4",
   "description": "Some glue to make gulp easier, perhaps even zero- or close-to-zero-conf",
   "bin": {
     "zarro": "./index.js"
@@ -61,7 +61,7 @@
     "decompress": "^4.2.1",
     "del": "^5.1.0",
     "event-stream": "^4.0.1",
-    "exec-step": "^0.11.0",
+    "exec-step": "^0.14.0",
     "fancy-log": "^1.3.3",
     "gulp": "^4.0.0",
     "gulp-debug": "^4.0.0",

package/types.d.ts

@@ -83,7 +83,7 @@ declare global {
   }
 
   interface Log {
-    setThreshold(level: number): void;
+    setThreshold(level: number | string): void;
 
     debug(...args: any[]): void;
 
@@ -1543,6 +1543,12 @@ declare global {
     preRelease?: boolean;
     configFile?: string;
     latestOnly?: boolean;
+    /**
+     * search results are typically cached in memory
+     * for 1 minute. If you absolutely _must_ have
+     * fresh data, set this to false
+     */
+    skipCache?: boolean;
   }
 
   interface DotNetInstallNugetPackageOption
@@ -1635,6 +1641,10 @@ declare global {
     preRelease?: boolean;
     noRestore?: boolean;
     source?: string;
+    /**
+     * defaults to true
+     */
+    showProgress?: boolean;
   }
 
   type DotNetTestFunction = (opts: DotNetTestOptions) => Promise<SystemResult | SystemError>;
@@ -2135,5 +2145,24 @@ declare global {
     "ZPL-1.1" |
     "ZPL-2.0" |
     "ZPL-2.1"
+
+  interface Cache {
+    read<T>(key: string, fallback?: T): Optional<T>;
+    write<T>(key: string, value: T, ttlSeconds: number): void;
+    through<T>(
+      key: string,
+      generator: Func<Promise<T>>,
+      ttlSeconds: number
+    ): Promise<T>;
+    throughSync<T>(
+      key: string,
+      generator: Func<T>,
+      ttlSeconds: number
+    ): T;
+    create(): Cache;
+    trim(): void;
+    forget(key: string): void;
+    clear(): void;
+  }
 }