@feiyoug/skill-lab 0.0.0 → 0.0.2

package/src/deps/jsr.io/@deno-library/progress/1.5.1/mod.ts

@@ -0,0 +1,265 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+import { bgGreen, bgWhite, stripAnsiCode } from "./deps.js";
+import { writeAll } from "./deps.js";
+// import type { Writer } from "./deps.ts";
+import { prettyTime, type prettyTimeOptions } from "./time.js";
+export { MultiProgressBar } from "./multi.js";
+
+const isTerminal = dntShim.Deno.stdout.isTerminal;
+
+const enum Direction {
+  left,
+  right,
+  all,
+}
+
+interface constructorOptions {
+  title?: string;
+  total?: number;
+  width?: number;
+  complete?: string;
+  preciseBar?: string[];
+  incomplete?: string;
+  clear?: boolean;
+  interval?: number;
+  display?: string;
+  prettyTime?: boolean;
+  output?: typeof dntShim.Deno.stdout | typeof dntShim.Deno.stderr;
+}
+
+interface renderOptions {
+  title?: string;
+  total?: number;
+  text?: string;
+  complete?: string;
+  preciseBar?: string[];
+  incomplete?: string;
+  prettyTimeOptions?: prettyTimeOptions;
+}
+
+/**
+ * ProgressBar single progress bar.
+ */
+export default class ProgressBar {
+  title: string;
+  total?: number;
+  width: number;
+  complete: string;
+  preciseBar: string[];
+  incomplete: string;
+  clear: boolean;
+  interval: number;
+  display: string;
+  prettyTime: boolean;
+
+  #end = false;
+  private lastStr = "";
+  private lastStrLen = 0;
+  private start = Date.now();
+  private lastRenderTime = 0;
+  private encoder = new TextEncoder();
+  // private writer: WritableStreamDefaultWriter<Uint8Array>;
+  // private writer: Writer;
+  private writer: typeof dntShim.Deno.stdout | typeof dntShim.Deno.stderr;
+
+  /**
+   * Title, total, complete, incomplete, can also be set or changed in the render method
+   *
+   * - title Progress bar title, default: ''
+   * - total total number of ticks to complete,
+   * - width the displayed width of the progress, default: 50
+   * - complete completion character, default: colors.bgGreen(' '), can use any string
+   * - incomplete incomplete character, default: colors.bgWhite(' '), can use any string
+   * - clear  clear the bar on completion, default: false
+   * - interval  minimum time between updates in milliseconds, default: 16
+   * - display  What is displayed and display order, default: ':title :percent :bar :time :completed/:total'
+   * - prettyTime Whether to pretty print time and eta
+   * - output Output stream, can be Deno.stdout or Deno.stderr, default is Deno.stdout
+   */
+  constructor({
+    title = "",
+    total,
+    width = 50,
+    complete = bgGreen(" "),
+    preciseBar = [],
+    incomplete = bgWhite(" "),
+    clear = false,
+    interval = 16,
+    display,
+    prettyTime = false,
+    output = dntShim.Deno.stdout,
+  }: constructorOptions = {}) {
+    this.title = title;
+    this.total = total;
+    this.width = width;
+    this.complete = complete;
+    this.preciseBar = preciseBar.concat(complete);
+    this.incomplete = incomplete;
+    this.clear = clear;
+    this.interval = interval;
+    this.display = display ??
+      ":title :percent :bar :time :completed/:total :text";
+    this.prettyTime = prettyTime;
+    // this.writer = output.writable.getWriter();
+    this.writer = output;
+  }
+
+  /**
+   * "render" the progress bar
+   *
+   * - `completed` completed value
+   * - `options` optional parameters
+   *   - `title` progress bar title
+   *   - `total` total number of ticks to complete
+   *   - `text` optional, custom text, default: ''
+   *   - `complete` completion character, If you want to change at a certain moment. For example, it turns red at 20%
+   *   - `incomplete` incomplete character, If you want to change at a certain moment. For example, it turns red at 20%
+   *   - `prettyTimeOptions` prettyTime options
+   */
+  async render(completed: number, options: renderOptions = {}): Promise<void> {
+    if (this.#end || !isTerminal) return;
+
+    if (completed < 0) {
+      throw new Error(`completed must greater than or equal to 0`);
+    }
+
+    const total = options.total ?? this.total ?? 100;
+    const now = Date.now();
+    const ms = now - this.lastRenderTime;
+    const end = completed >= total;
+    if (ms < this.interval && !end) return;
+
+    this.lastRenderTime = now;
+    const time = this.prettyTime
+      ? prettyTime(now - this.start, options.prettyTimeOptions)
+      : ((now - this.start) / 1000).toFixed(1) + "s";
+    const msEta = completed >= total
+      ? 0
+      : (total / completed - 1) * (now - this.start);
+    const eta = completed == 0
+      ? "-"
+      : this.prettyTime
+      ? prettyTime(msEta, options.prettyTimeOptions)
+      : (msEta / 1000).toFixed(1) + "s";
+
+    const percent = ((completed / total) * 100).toFixed(2) + "%";
+
+    // :title :percent :bar :time :completed/:total
+    let str = this.display
+      .replace(":title", options.title ?? this.title)
+      .replace(":time", time)
+      .replace(":text", options.text ?? "")
+      .replace(":eta", eta)
+      .replace(":percent", percent)
+      .replace(":completed", completed + "")
+      .replace(":total", total + "");
+
+    // compute the available space (non-zero) for the bar
+    const availableSpace = Math.max(
+      0,
+      this.ttyColumns - stripAnsiCode(str.replace(":bar", "")).length,
+    );
+
+    const width = Math.min(this.width, availableSpace);
+
+    const preciseBar = options.preciseBar ?? this.preciseBar;
+    const precision = preciseBar.length > 1;
+
+    // :bar
+    const completeLength = (width * completed) / total;
+    const roundedCompleteLength = Math.floor(completeLength);
+
+    let precise = "";
+    if (precision) {
+      const preciseLength = completeLength - roundedCompleteLength;
+      precise = end
+        ? ""
+        : preciseBar[Math.floor(preciseBar.length * preciseLength)];
+    }
+
+    const complete = new Array(roundedCompleteLength)
+      .fill(options.complete ?? this.complete)
+      .join("");
+    const incomplete = new Array(
+      Math.max(width - roundedCompleteLength - (precision ? 1 : 0), 0),
+    )
+      .fill(options.incomplete ?? this.incomplete)
+      .join("");
+
+    str = str.replace(":bar", complete + precise + incomplete);
+
+    if (str !== this.lastStr) {
+      const strLen = stripAnsiCode(str).length;
+      if (strLen < this.lastStrLen) {
+        str += " ".repeat(this.lastStrLen - strLen);
+      }
+      await this.write(str);
+      this.lastStr = str;
+      this.lastStrLen = strLen;
+    }
+
+    if (end) await this.end();
+  }
+
+  /**
+   * end: end a progress bar.
+   * No need to call in most cases, unless you want to end before 100%
+   */
+  async end(): Promise<void> {
+    if (this.#end) return;
+    this.#end = true;
+    if (this.clear) {
+      await this.stdoutWrite("\r");
+      await this.clearLine();
+    } else {
+      await this.breakLine();
+    }
+    await this.showCursor();
+    // this.writer.releaseLock();
+  }
+
+  /**
+   * interrupt the progress bar and write a message above it
+   *
+   * @param message The message to write
+   */
+  async console(message: string | number): Promise<void> {
+    await this.clearLine();
+    await this.write(`${message}`);
+    await this.breakLine();
+    await this.write(this.lastStr);
+  }
+
+  private write(msg: string): Promise<void> {
+    return this.stdoutWrite(`\r${msg}\x1b[?25l`);
+  }
+
+  private get ttyColumns(): number {
+    if (!dntShim.Deno.stdout.isTerminal()) return 100;
+    return dntShim.Deno.consoleSize().columns;
+  }
+
+  private breakLine(): Promise<void> {
+    return this.stdoutWrite("\n");
+  }
+
+  private stdoutWrite(msg: string): Promise<void> {
+    // return this.writer.write(this.encoder.encode(msg));
+    return writeAll(this.writer, this.encoder.encode(msg))
+  }
+
+  private clearLine(direction: Direction = Direction.all): Promise<void> {
+    switch (direction) {
+      case Direction.all:
+        return this.stdoutWrite("\x1b[2K");
+      case Direction.left:
+        return this.stdoutWrite("\x1b[1K");
+      case Direction.right:
+        return this.stdoutWrite("\x1b[0K");
+    }
+  }
+
+  private showCursor(): Promise<void> {
+    return this.stdoutWrite("\x1b[?25h");
+  }
+}

package/src/deps/jsr.io/@deno-library/progress/1.5.1/multi.ts

@@ -0,0 +1,250 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+import { bgGreen, bgWhite, stripAnsiCode } from "./deps.js";
+import { writeAll } from "./deps.js";
+// import type { Writer } from "./deps.ts";
+import { prettyTime, type prettyTimeOptions } from "./time.js";
+
+const isTerminal = dntShim.Deno.stdout.isTerminal;
+
+interface constructorOptions {
+  title?: string;
+  width?: number;
+  complete?: string;
+  incomplete?: string;
+  clear?: boolean;
+  interval?: number;
+  display?: string;
+  prettyTime?: boolean;
+  output?: typeof dntShim.Deno.stdout | typeof dntShim.Deno.stderr;
+}
+
+interface renderOptions {
+  completed: number;
+  text?: string;
+  total?: number;
+  complete?: string;
+  incomplete?: string;
+  prettyTimeOptions?: prettyTimeOptions;
+}
+
+interface bar {
+  str: string;
+  strLen?: number;
+  end?: boolean;
+}
+
+/**
+ * MultiProgressBar multiple progress bars.
+ */
+export class MultiProgressBar {
+  width: number;
+  complete: string;
+  incomplete: string;
+  clear: boolean;
+  interval: number;
+  display: string;
+  prettyTime: boolean;
+
+  #end = false;
+  #startIndex = 0;
+  #lastRows = 0;
+  #bars: bar[] = [];
+  private lastStr = "";
+  private start = Date.now();
+  private lastRenderTime = 0;
+  private encoder = new TextEncoder();
+  // private writer: WritableStreamDefaultWriter<Uint8Array>;
+  // private writer: Writer;
+  private writer: typeof dntShim.Deno.stdout | typeof dntShim.Deno.stderr;
+
+  /**
+   * Title, total, complete, incomplete, can also be set or changed in the render method
+   *
+   * - title Progress bar title, default: ''
+   * - width the displayed width of the progress, default: 50
+   * - complete completion character, default: colors.bgGreen(' '), can use any string
+   * - incomplete incomplete character, default: colors.bgWhite(' '), can use any string
+   * - clear  clear the bar on completion, default: false
+   * - interval  minimum time between updates in milliseconds, default: 16
+   * - display  What is displayed and display order, default: ':bar :text :percent :time :completed/:total'
+   * - prettyTime Whether to pretty print time and eta
+   * - output Output stream, can be Deno.stdout or Deno.stderr, default is Deno.stdout
+   */
+  constructor({
+    title = "",
+    width = 50,
+    complete = bgGreen(" "),
+    incomplete = bgWhite(" "),
+    clear = false,
+    interval,
+    display,
+    prettyTime = false,
+    output = dntShim.Deno.stdout,
+  }: constructorOptions = {}) {
+    if (title != "") {
+      this.#bars.push({ str: title });
+      this.#startIndex = 1;
+    }
+    this.width = width;
+    this.complete = complete;
+    this.incomplete = incomplete;
+    this.clear = clear;
+    this.interval = interval ?? 16;
+    this.display = display ?? ":bar :text :percent :time :completed/:total";
+    this.prettyTime = prettyTime;
+    // this.writer = output.writable.getWriter();
+    this.writer = output;
+  }
+
+  /**
+   * "render" the progress bar
+   *
+   * - `bars` progress bars
+   *   - `completed` completed value
+   *   - `total` optional, total number of ticks to complete, default: 100
+   *   - `text` optional, text displayed per ProgressBar, default: ''
+   *   - `complete` - optional, completion character
+   *   - `incomplete` - optional, incomplete character
+   *   - `prettyTimeOptions` - prettyTime options
+   */
+  async render(bars: Array<renderOptions>): Promise<void> {
+    if (this.#end || !isTerminal) return;
+
+    const now = Date.now();
+    const ms = now - this.lastRenderTime;
+    this.lastRenderTime = now;
+    let end = true;
+    let index = this.#startIndex;
+
+    for (const { completed, total = 100, text = "", ...options } of bars) {
+      if (completed < 0) {
+        throw new Error(`completed must greater than or equal to 0`);
+      }
+      if (!Number.isInteger(total)) throw new Error(`total must be 'number'`);
+      if (this.#bars[index] && this.#bars[index].end) {
+        index++;
+        continue;
+      }
+      end = false;
+      const percent = ((completed / total) * 100).toFixed(2) + "%";
+      const time = this.prettyTime
+        ? prettyTime(now - this.start, options.prettyTimeOptions)
+        : ((now - this.start) / 1000).toFixed(1) + "s";
+      const msEta = completed >= total
+        ? 0
+        : (total / completed - 1) * (now - this.start);
+      const eta = completed == 0
+        ? "-"
+        : this.prettyTime
+        ? prettyTime(msEta, options.prettyTimeOptions)
+        : (msEta / 1000).toFixed(1) + "s";
+
+      // :bar :text :percent :time :completed/:total
+      let str = this.display
+        .replace(":text", text)
+        .replace(":time", time)
+        .replace(":eta", eta)
+        .replace(":percent", percent)
+        .replace(":completed", completed + "")
+        .replace(":total", total + "");
+
+      // compute the available space (non-zero) for the bar
+      const availableSpace = Math.max(
+        0,
+        this.ttyColumns - stripAnsiCode(str.replace(":bar", "")).length,
+      );
+
+      const width = Math.min(this.width, availableSpace);
+      // :bar
+      const completeLength = Math.round((width * completed) / total);
+      const complete = new Array(completeLength)
+        .fill(options.complete ?? this.complete)
+        .join("");
+      const incomplete = new Array(width - completeLength)
+        .fill(options.incomplete ?? this.incomplete)
+        .join("");
+
+      str = str.replace(":bar", complete + incomplete);
+      const strLen = stripAnsiCode(str).length;
+      if (this.#bars[index] && str != this.#bars[index].str) {
+        const lastStrLen = this.#bars[index].strLen!;
+        if (strLen < lastStrLen) {
+          str += " ".repeat(lastStrLen - strLen);
+        }
+      }
+
+      this.#bars[index++] = {
+        str,
+        strLen,
+        end: completed >= total,
+      };
+    }
+    if (ms < this.interval && !end) return;
+    const str = this.#bars.map((v) => v.str).join("\n");
+
+    if (str !== this.lastStr) {
+      await this.resetScreen();
+      await this.write(str);
+      this.lastStr = str;
+      this.#lastRows = this.#bars.length;
+    }
+
+    if (end) await this.end();
+  }
+
+  /**
+   * end: end a progress bar.
+   * No need to call in most cases, unless you want to end before 100%
+   */
+  async end(): Promise<void> {
+    if (this.#end) return;
+    this.#end = true;
+    if (this.clear) {
+      await this.resetScreen();
+    } else {
+      await this.breakLine();
+    }
+    await this.showCursor();
+    // this.writer.releaseLock();
+  }
+
+  /**
+   * interrupt the progress bar and write a message above it
+   *
+   * @param message The message to write
+   */
+  async console(message: string | number): Promise<void> {
+    await this.resetScreen();
+    await this.write(`${message}`);
+    await this.breakLine();
+    await this.write(this.lastStr);
+  }
+
+  private write(msg: string): Promise<void> {
+    return this.stdoutWrite(`${msg}\x1b[?25l`);
+  }
+
+  private async resetScreen(): Promise<void> {
+    if (this.#lastRows > 0) {
+      await this.stdoutWrite("\x1b[" + (this.#lastRows - 1) + "A\r\x1b[?0J");
+    }
+  }
+
+  private get ttyColumns(): number {
+    if (!dntShim.Deno.stdout.isTerminal()) return 100;
+    return dntShim.Deno.consoleSize().columns;
+  }
+
+  private breakLine(): Promise<void> {
+    return this.stdoutWrite("\n");
+  }
+
+  private stdoutWrite(msg: string): Promise<void> {
+    // return this.writer.write(this.encoder.encode(msg));
+    return writeAll(this.writer, this.encoder.encode(msg))
+  }
+
+  private showCursor(): Promise<void> {
+    return this.stdoutWrite("\x1b[?25h");
+  }
+}

package/src/deps/jsr.io/@deno-library/progress/1.5.1/time.ts

@@ -0,0 +1,69 @@
+/**
+ * prettyTime options
+ * - withSpaces Whether to use spaces to separate times, `1d2h3m5s` or `1d 2h 3m 5s`, default false
+ * - toFixedVal value pass to toFixed for seconds, default 1
+ * - longFormat Whether to use a long format, default false, `1d2h3m5s` or `1days 2hours 3minutes 5seconds`
+ */
+export interface prettyTimeOptions {
+  withSpaces?: boolean;
+  toFixedVal?: number;
+  longFormat?: boolean;
+}
+
+/**
+ * Convert time duration to a human readable string: 5d1h20m30s
+ *
+ * - milliseconds The number to format, unit milliseconds
+ */
+export function prettyTime(
+  milliseconds: number,
+  options: prettyTimeOptions = {
+    withSpaces: false,
+    toFixedVal: 1,
+    longFormat: false,
+  },
+): string {
+  let second = milliseconds / 1000;
+  if (second < 60) {
+    return unitToString(second, 0, options);
+  }
+  let minute = Math.floor(second / 60);
+  second %= 60;
+  if (minute < 60) {
+    return unitToString(minute, 1, options) + unitToString(second, 0, options);
+  }
+  let hour = Math.floor(minute / 60);
+  minute %= 60;
+  if (hour < 24) {
+    return (
+      unitToString(hour, 2, options) +
+      unitToString(minute, 1, options) +
+      unitToString(second, 0, options)
+    );
+  }
+  const day = Math.floor(hour / 24);
+  hour %= 24;
+  return (
+    unitToString(day, 3, options) +
+    unitToString(hour, 2, options) +
+    unitToString(minute, 1, options) +
+    unitToString(second, 0, options)
+  );
+}
+
+function unitToString(
+  val: number,
+  i: number,
+  { withSpaces = false, toFixedVal = 1, longFormat = false }: prettyTimeOptions,
+): string {
+  const units = longFormat
+    ? ["second", "minute", "hour", "day"]
+    : ["s", "m", "h", "d"];
+  const unit = longFormat && (val >= 2 || (val > 1 && toFixedVal > 0))
+    ? units[i] + "s"
+    : units[i];
+  if (i == 0) {
+    return val.toFixed(toFixedVal) + unit;
+  }
+  return val + (withSpaces ? unit + " " : unit);
+}