@playcanvas/splat-transform 2.0.0 → 2.0.1

package/dist/cli.mjs

@@ -11422,37 +11422,19 @@ class LoggerCore {
         return verbosityRank[this.verbosity] >= verbosityRank[messageMinVerbosity[level]];
     }
     /**
-     * Gate events by the current verbosity, then hand survivors to the
-     * renderer. Renderers see only visible events and never need to know
-     * about verbosity themselves.
+     * Hand the event to the renderer. Lifecycle events (`scopeStart`,
+     * `scopeEnd`, `barStart`, `barTick`, `barEnd`) and `output` are always
+     * forwarded; presentation policy (e.g. hiding successful `scopeEnd`
+     * footers at non-`verbose` verbosity) lives in the renderer so
+     * embedders consuming the event stream see a complete, faithful
+     * record of scope and bar lifecycles. `message` is assumed already
+     * gated at the façade via {@link LoggerCore.isLevelVisible} (so
+     * callers can skip formatting args for filtered levels); anything
+     * that reaches here is passed through.
      *
-     * - `output` is always shown (it's the pipeable channel).
-     * - `message` is assumed already gated at the façade via
-     *   {@link LoggerCore.isLevelVisible} (so callers can skip formatting
-     *   args for filtered levels); anything that reaches here is passed
-     *   through.
-     * - `scopeEnd` footers are noisy on the success path, so success-ends
-     *   are gated one rank higher than their matching start: visible only
-     *   at `verbose`, while `scopeStart` shows at `normal`. Failed ends
-     *   stay at the `normal` gate so the "failed in Xs" cascade from
-     *   `logger.error` / `unwindAll(true)` survives whenever scope
-     *   output is visible at all.
-     * - All other scope/bar events (`scopeStart`, `barStart`, `barTick`,
-     *   `barEnd`) are gated at `normal`.
-     *
-     * @param event - The candidate event.
+     * @param event - The event to deliver.
      */
     emit(event) {
-        if (event.kind !== 'output' && event.kind !== 'message') {
-            const rank = verbosityRank[this.verbosity];
-            if (event.kind === 'scopeEnd' && !event.failed) {
-                if (rank < verbosityRank.verbose)
-                    return;
-            }
-            else if (rank < verbosityRank.normal) {
-                return;
-            }
-        }
         this.renderer.handle(event);
     }
     /**
@@ -11729,7 +11711,10 @@ const logger = {
     },
     /**
      * Replace the active renderer. Embedders install their own renderer here
-     * to consume `LogEvent`s; the default renderer is a no-op.
+     * to consume `LogEvent`s; the default renderer is a no-op. Renderers
+     * receive every scope/bar lifecycle event regardless of verbosity, so
+     * progress UIs can rely on `scopeStart`/`scopeEnd` and `barStart`/`barEnd`
+     * to manage their state.
      * @param r - The renderer to install.
      */
     setRenderer(r) {
@@ -12238,20 +12223,27 @@ const indent = (depth) => '  '.repeat(Math.max(0, depth));
 const BAR_WIDTH = 20;
 /**
  * Default human-readable text renderer. Emits one event per line - no
- * carriage-return rewriting, no TTY detection, no buffering. Scope starts
- * always emit a header line; successful `scopeEnd` footers are filtered
- * out at `normal` verbosity by `LoggerCore` (kept at `verbose`, and always
- * shown when `failed`), so default-mode runs see headers without timing
- * footers and `--verbose` adds the matching `done in ...` lines. Bars
- * render as `[#### ...... ] duration`, with `#` appended incrementally on
- * each `barTick` and the remainder padded with `.` on `barEnd`. `output`
+ * carriage-return rewriting, no TTY detection, no buffering. Bars render
+ * as `[#### ...... ] duration`, with `#` appended incrementally on each
+ * `barTick` and the remainder padded with `.` on `barEnd`. `output`
  * events are treated as line-oriented: their text is written to the
  * pipeable sink with a trailing `\n` appended (callers should not include
  * one themselves).
  *
- * Verbosity filtering is handled centrally by `LoggerCore` - this renderer
- * receives only events that have already passed the visibility gate, so it
- * is pure presentation.
+ * Verbosity is consulted directly from the shared {@link logger} on each
+ * event, so this renderer alone decides what to display - the core
+ * delivers every scope/bar lifecycle event so embedders consuming the
+ * event stream see a faithful record. The display rules are:
+ *
+ * - `quiet` - suppresses every scope/bar lifecycle line (start, tick,
+ *   end - including failed ends). Errors, warnings and `output` still
+ *   show.
+ * - `normal` (default) - shows scope/bar headers and bar progress;
+ *   shows failed `scopeEnd` / `barEnd` footers (the "failed in ..."
+ *   cascade from `logger.error` / `unwindAll(true)`); hides successful
+ *   `scopeEnd` footers.
+ * - `verbose` - shows everything, including successful `scopeEnd`
+ *   footers ("done in ...").
  *
  * Sinks are injected (no `process` reference here) so the renderer works in
  * both Node CLI and browser/bundle contexts: the CLI passes
@@ -12274,9 +12266,14 @@ class TextRenderer {
         this.output = options.output ?? options.write;
         this.getMemoryUsage = options.getMemoryUsage;
     }
+    rank() {
+        return verbosityRank[logger.getVerbosity()];
+    }
     handle(event) {
         switch (event.kind) {
             case 'scopeStart': {
+                if (this.rank() < verbosityRank.normal)
+                    return;
                 this.commitDirty();
                 const numbered = event.index !== undefined && event.total !== undefined ?
                     `[${event.index}/${event.total}] ` : '';
@@ -12284,12 +12281,22 @@ class TextRenderer {
                 return;
             }
             case 'scopeEnd': {
+                const rank = this.rank();
+                if (event.failed) {
+                    if (rank < verbosityRank.normal)
+                        return;
+                }
+                else if (rank < verbosityRank.verbose) {
+                    return;
+                }
                 this.commitDirty();
                 const verb = event.failed ? 'failed in' : 'done in';
                 this.write(`${indent(event.depth + 1)}${verb} ${fmtTime(event.durationMs)}${this.memSuffix()}\n`);
                 return;
             }
             case 'barStart': {
+                if (this.rank() < verbosityRank.normal)
+                    return;
                 this.commitDirty();
                 this.write(`${indent(event.depth)}\u25b8 ${event.name} [`);
                 this.lineDirty = true;
@@ -12299,6 +12306,8 @@ class TextRenderer {
             case 'barTick': {
                 if (!this.lineDirty)
                     return;
+                if (this.rank() < verbosityRank.normal)
+                    return;
                 const target = event.total <= 0 ? 0 :
                     Math.min(BAR_WIDTH, Math.floor((event.current / event.total) * BAR_WIDTH));
                 if (target > this.barFilled) {
@@ -12308,6 +12317,8 @@ class TextRenderer {
                 return;
             }
             case 'barEnd': {
+                if (this.rank() < verbosityRank.normal)
+                    return;
                 const suffix = event.failed ?
                     `] (failed) ${fmtTime(event.durationMs)}` :
                     `] ${fmtTime(event.durationMs)}`;
@@ -17464,7 +17475,14 @@ class CompressedChunk {
     }
 }
 
-var version = "2.0.0";
+/**
+ * The splat-transform version (semver MAJOR.MINOR.PATCH).
+ */
+const version = '2.0.1';
+/**
+ * The splat-transform revision (short Git hash of HEAD at build time).
+ */
+const revision = '129f87d';
 
 const generatedByString = `Generated by splat-transform ${version}`;
 const chunkProps = [
@@ -26387,7 +26405,7 @@ const main = async () => {
     else {
         logger.setVerbosity('normal');
     }
-    logger.info(`splat-transform v${version}`);
+    logger.info(`splat-transform v${version} (${revision})`);
     // show version and exit
     if (options.version) {
         exit(0);