@andrew_l/toolkit 0.3.5 → 0.3.7

package/dist/index.cjs

@@ -832,7 +832,7 @@ function uniqBy(array, comparator) {
   });
 }
 
-class BrowserAssertionError extends Error {
+class AssertionError extends Error {
   /**
    * Set to the `actual` argument for methods such as {@link assert.strictEqual()}.
    */
@@ -863,17 +863,6 @@ class BrowserAssertionError extends Error {
   }
 }
 
-let AssertionError = BrowserAssertionError;
-if (isNode()) {
-  try {
-    const assert = require("node:assert");
-    if (assert.AssertionError) {
-      AssertionError = assert.AssertionError;
-    }
-  } catch {
-  }
-}
-
 function ok(value, message) {
   if (!value) {
     throw toError$1(
@@ -1594,8 +1583,12 @@ class Base64Encoding {
     }
     this.alphabet = alphabet;
     this.padding = options?.padding ?? "=";
-    if (this.alphabet.includes(this.padding) || this.padding.length !== 1) {
-      throw new Error("Invalid padding");
+    if (this.padding) {
+      ok(
+        !this.alphabet.includes(this.padding),
+        "Padding cannot be a part of alphabet"
+      );
+      ok(this.padding.length === 1, "Padding length must be a 1");
     }
     for (let i = 0; i < alphabet.length; i++) {
       this.decodeMap.set(alphabet[i], i);
@@ -1614,26 +1607,24 @@ class Base64Encoding {
    * ```
    */
   encode(data, options) {
+    const includePadding = options?.includePadding ?? true;
     let result = "";
     let buffer = 0;
     let shift = 0;
-    for (let i = 0; i < data.length; i++) {
-      buffer = buffer << 8 | data[i];
+    for (const byte of data) {
+      buffer = buffer << 8 | byte;
       shift += 8;
       while (shift >= 6) {
-        shift += -6;
+        shift -= 6;
         result += this.alphabet[buffer >> shift & 63];
       }
     }
     if (shift > 0) {
       result += this.alphabet[buffer << 6 - shift & 63];
     }
-    const includePadding = options?.includePadding ?? true;
-    if (includePadding) {
+    if (includePadding && this.padding) {
       const padCount = (4 - result.length % 4) % 4;
-      for (let i = 0; i < padCount; i++) {
-        result += "=";
-      }
+      result += "=".repeat(padCount);
     }
     return result;
   }
@@ -1652,39 +1643,23 @@ class Base64Encoding {
    */
   decode(data, options) {
     const strict = options?.strict ?? true;
-    const chunkCount = Math.ceil(data.length / 4);
     const result = [];
-    for (let i = 0; i < chunkCount; i++) {
-      let padCount = 0;
-      let buffer = 0;
-      for (let j = 0; j < 4; j++) {
-        const encoded = data[i * 4 + j];
-        if (encoded === "=") {
-          if (i + 1 !== chunkCount) {
-            throw new Error(`Invalid character: ${encoded}`);
-          }
-          padCount += 1;
-          continue;
-        }
-        if (encoded === void 0) {
-          if (strict) {
-            throw new Error("Invalid data");
-          }
-          padCount += 1;
-          continue;
-        }
-        const value = this.decodeMap.get(encoded) ?? null;
-        if (value === null) {
-          throw new Error(`Invalid character: ${encoded}`);
-        }
-        buffer += value << 6 * (3 - j);
-      }
-      result.push(buffer >> 16 & 255);
-      if (padCount < 2) {
-        result.push(buffer >> 8 & 255);
+    let buffer = 0;
+    let bitsCollected = 0;
+    if (this.padding && strict) {
+      ok(data.length % 4 === 0, "Invalid Base64 data");
+    }
+    for (const char of data) {
+      if (char === this.padding) break;
+      const value = this.decodeMap.get(char);
+      if (value === void 0) {
+        throw new Error(`Invalid Base64 character: ${char}`);
       }
-      if (padCount < 1) {
-        result.push(buffer & 255);
+      buffer = buffer << 6 | value;
+      bitsCollected += 6;
+      if (bitsCollected >= 8) {
+        bitsCollected -= 8;
+        result.push(buffer >> bitsCollected & 255);
       }
     }
     return Uint8Array.from(result);
@@ -1698,10 +1673,22 @@ const base64url = new Base64Encoding(
   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
 );
 
-function base64ToBytes(data, { encoding = "base64", strict } = {}) {
+function base64ToBytes(data, { encoding = "base64", strict, native = true } = {}) {
   if (encoding === "base64") {
+    if (native && isFunction(Uint8Array.fromBase64)) {
+      return Uint8Array.fromBase64(data, {
+        alphabet: "base64",
+        lastChunkHandling: strict ?? true ? "strict" : "loose"
+      });
+    }
     return base64.decode(data, { strict: strict ?? true });
   } else if (encoding === "base64url") {
+    if (native && isFunction(Uint8Array.fromBase64)) {
+      return Uint8Array.fromBase64(data, {
+        alphabet: "base64url",
+        lastChunkHandling: strict ?? false ? "strict" : "loose"
+      });
+    }
     return base64url.decode(data, { strict: strict ?? false });
   }
   ok(false, "Invalid encoding options: " + encoding);
@@ -2165,10 +2152,22 @@ function buildFieldsInfo(fields, totalBits) {
   return result;
 }
 
-function bytesToBase64(data, { encoding = "base64", padding } = {}) {
+function bytesToBase64(data, { encoding = "base64", padding, native = true } = {}) {
   if (encoding === "base64") {
+    if (native && isFunction(data.toBase64)) {
+      return data.toBase64({
+        alphabet: "base64",
+        omitPadding: !(padding ?? true)
+      });
+    }
     return base64.encode(data, { includePadding: padding ?? true });
   } else if (encoding === "base64url") {
+    if (native && isFunction(data.toBase64)) {
+      return data.toBase64({
+        alphabet: "base64url",
+        omitPadding: !(padding ?? false)
+      });
+    }
     return base64url.encode(data, { includePadding: padding ?? false });
   }
   ok(false, "Invalid encoding options: " + encoding);
@@ -2193,6 +2192,47 @@ function concatenateBytes(a, b) {
   return result;
 }
 
+function rleDecode(buf, value = 0) {
+  const result = [];
+  let i = 0;
+  while (i < buf.length) {
+    if (buf[i] === value) {
+      const count = buf[i + 1];
+      for (let j = 0; j < count; j++) {
+        result.push(value);
+      }
+      i += 2;
+    } else {
+      result.push(buf[i]);
+      i++;
+    }
+  }
+  return new Uint8Array(result);
+}
+
+function rleEncode(buf, value = 0) {
+  const result = [];
+  let i = 0;
+  while (i < buf.length) {
+    if (buf[i] === value) {
+      const runStart = i;
+      while (i < buf.length && buf[i] === value) {
+        i++;
+      }
+      let runLength = i - runStart;
+      while (runLength > 0) {
+        const chunk = Math.min(runLength, 255);
+        result.push(value, chunk);
+        runLength -= chunk;
+      }
+    } else {
+      result.push(buf[i]);
+      i++;
+    }
+  }
+  return new Uint8Array(result);
+}
+
 function uint16ToUint8(value) {
   const uint8Array = new Uint8Array(value.length * 2);
   for (let i = 0; i < value.length; i++) {
@@ -5178,17 +5218,28 @@ function throttle(func, throttleMs, { signal, edges = ["leading", "trailing"] }
   return throttled;
 }
 
-const LEVEL_NUM = {
+const LEVEL_NAME_TO_NUM = {
   debug: 0,
   log: 1,
   info: 2,
   warn: 3,
   error: 4
 };
-let currentLogLevel = LEVEL_NUM.log;
-const loggerSetLevel = (level) => {
-  number$1(LEVEL_NUM[level], `Invalid log level: ${level}`);
-  currentLogLevel = LEVEL_NUM[level];
+const LEVEL_NUM_TO_NAME = {
+  0: "debug",
+  1: "log",
+  2: "info",
+  3: "warn",
+  4: "error"
+};
+const LOG_LEVEL = env.string("LOG_LEVEL", "info");
+let currentLogLevel = LOG_LEVEL in LEVEL_NAME_TO_NUM ? LEVEL_NAME_TO_NUM[LOG_LEVEL] : LEVEL_NAME_TO_NUM.log;
+const setLoggerLevel = (level) => {
+  number$1(LEVEL_NAME_TO_NUM[level], `Invalid log level: ${level}`);
+  currentLogLevel = LEVEL_NAME_TO_NUM[level];
+};
+const getLoggerLevel = () => {
+  return LEVEL_NUM_TO_NAME[currentLogLevel];
 };
 const logger = (...baseArgs) => {
   if (isString(baseArgs[0]?.url)) {
@@ -5198,7 +5249,7 @@ const logger = (...baseArgs) => {
     baseArgs[0] = `[${baseArgs[0].split("/").at(-1).split("?", 1)[0]}]`;
   }
   const writeLog = (level, ...[pattern, ...args]) => {
-    const levelNum = LEVEL_NUM[level];
+    const levelNum = LEVEL_NAME_TO_NUM[level];
     if (levelNum < currentLogLevel) {
       return;
     }
@@ -5926,6 +5977,135 @@ class ResourcePool extends SimpleEventEmitter {
   }
 }
 
+const SCHEDULER_JOB_FLAGS = {
+  QUEUED: 1 << 0,
+  ALLOW_RECURSE: 1 << 2,
+  DISPOSED: 1 << 3
+};
+function createScheduler() {
+  return new Scheduler();
+}
+class Scheduler {
+  queue = [];
+  flushIndex = -1;
+  resolvedPromise = Promise.resolve();
+  currentFlushPromise = null;
+  onJobCbs = [];
+  onJobStartCbs = [];
+  onJobCompleteCbs = [];
+  constructor() {
+    for (const methodName of Object.getOwnPropertyNames(
+      Object.getPrototypeOf(this)
+    )) {
+      this[methodName] = this[methodName].bind(this);
+    }
+  }
+  onJob(fn) {
+    this.onJobCbs.push(fn);
+  }
+  onJobStart(fn) {
+    this.onJobStartCbs.push(fn);
+  }
+  onJobComplete(fn) {
+    this.onJobCompleteCbs.push(fn);
+  }
+  nextTick(fn) {
+    const p = this.currentFlushPromise || this.resolvedPromise;
+    return fn ? p.then(this ? fn.bind(this) : fn) : p;
+  }
+  queueJob(job, opts) {
+    if (opts) {
+      Object.assign(job, opts);
+    }
+    if (!(job.flags & SCHEDULER_JOB_FLAGS.QUEUED)) {
+      const jobId = getId(job);
+      const lastJob = this.queue[this.queue.length - 1];
+      if (!lastJob || jobId >= getId(lastJob)) {
+        this.queue.push(job);
+      } else {
+        this.queue.splice(this.findInsertionIndex(jobId), 0, job);
+      }
+      job.flags |= SCHEDULER_JOB_FLAGS.QUEUED;
+      this.queueFlush();
+      for (const hookFn of this.onJobCbs) {
+        hookFn(job);
+      }
+    }
+  }
+  queueJobWait(job, opts) {
+    return new CancellablePromise((resolve, reject, onCancel) => {
+      onCancel(() => {
+        job.flags |= SCHEDULER_JOB_FLAGS.DISPOSED;
+        reject(new Error("Canceled"));
+      });
+      const fn = () => {
+        return Promise.resolve().then(() => job()).then(resolve).catch(reject);
+      };
+      fn.id = job.id;
+      fn.flags = job.flags;
+      this.queueJob(fn, opts);
+    });
+  }
+  findInsertionIndex(id) {
+    let start = this.flushIndex + 1;
+    let end = this.queue.length;
+    while (start < end) {
+      const middle = start + end >>> 1;
+      const middleJob = this.queue[middle];
+      const middleJobId = getId(middleJob);
+      if (middleJobId < id) {
+        start = middle + 1;
+      } else {
+        end = middle;
+      }
+    }
+    return start;
+  }
+  async flushJobs() {
+    try {
+      for (this.flushIndex = 0; this.flushIndex < this.queue.length; this.flushIndex++) {
+        const job = this.queue[this.flushIndex];
+        if (job && !(job.flags & SCHEDULER_JOB_FLAGS.DISPOSED)) {
+          if (job.flags & SCHEDULER_JOB_FLAGS.ALLOW_RECURSE) {
+            job.flags &= ~SCHEDULER_JOB_FLAGS.QUEUED;
+          }
+          for (const hookFn of this.onJobStartCbs) {
+            hookFn(job);
+          }
+          await job();
+          for (const hookFn of this.onJobCompleteCbs) {
+            hookFn(job);
+          }
+          if (!(job.flags & SCHEDULER_JOB_FLAGS.ALLOW_RECURSE)) {
+            job.flags &= ~SCHEDULER_JOB_FLAGS.QUEUED;
+          }
+        }
+      }
+    } finally {
+      for (; this.flushIndex < this.queue.length; this.flushIndex++) {
+        const job = this.queue[this.flushIndex];
+        if (job) {
+          job.flags &= ~SCHEDULER_JOB_FLAGS.QUEUED;
+        }
+      }
+      this.flushIndex = -1;
+      this.queue.length = 0;
+      this.currentFlushPromise = null;
+      if (this.queue.length) {
+        return this.flushJobs();
+      }
+    }
+  }
+  queueFlush() {
+    if (!this.currentFlushPromise) {
+      this.currentFlushPromise = this.resolvedPromise.then(this.flushJobs);
+    }
+  }
+}
+function getId(job) {
+  return job.id == null ? Infinity : job.id;
+}
+
 function timeout(ms, promiseOrCallback, timeoutError = new AppError(408)) {
   const abortController = new AbortController();
   let taskResult;
@@ -6011,8 +6191,8 @@ function withResolve(fn, getCacheKey) {
 }
 
 exports.AppError = AppError;
+exports.AssertionError = AssertionError;
 exports.AsyncIterableQueue = AsyncIterableQueue;
-exports.BrowserAssertionError = BrowserAssertionError;
 exports.CancellablePromise = CancellablePromise;
 exports.ColorParser = ColorParser;
 exports.EJSON = instance;
@@ -6024,6 +6204,8 @@ exports.FixedWeakMap = FixedWeakMap;
 exports.LruCache = LruCache;
 exports.Queue = Queue;
 exports.ResourcePool = ResourcePool;
+exports.SCHEDULER_JOB_FLAGS = SCHEDULER_JOB_FLAGS;
+exports.Scheduler = Scheduler;
 exports.SimpleEventEmitter = SimpleEventEmitter;
 exports.SortedArray = SortedArray;
 exports.TWEMOJI_REGEX = TWEMOJI_REGEX;
@@ -6083,6 +6265,7 @@ exports.createEJSONStream = createEJSONStream;
 exports.createEnvParser = createEnvParser;
 exports.createFunction = createFunction;
 exports.createRandomizer = createRandomizer;
+exports.createScheduler = createScheduler;
 exports.createSecureCustomizer = createSecureCustomizer;
 exports.createTimeObject = createTimeObject;
 exports.createTimeSpan = createTimeSpan;
@@ -6117,6 +6300,7 @@ exports.get = get;
 exports.getFileExtension = getFileExtension;
 exports.getFileName = getFileName;
 exports.getInitials = getInitials;
+exports.getLoggerLevel = getLoggerLevel;
 exports.getMostSpecificPaths = getMostSpecificPaths;
 exports.getRandomInt = getRandomInt;
 exports.getRandomTime = getRandomTime;
@@ -6174,7 +6358,6 @@ exports.isoToFlagEmoji = isoToFlagEmoji;
 exports.kebabCase = kebabCase;
 exports.keyBy = keyBy;
 exports.logger = logger;
-exports.loggerSetLevel = loggerSetLevel;
 exports.lowerCase = lowerCase;
 exports.luminance = luminance;
 exports.maskingEmail = maskingEmail;
@@ -6198,9 +6381,12 @@ exports.randomString = randomString;
 exports.removeVS16s = removeVS16s;
 exports.retryOnError = retryOnError;
 exports.rgbToChannels = rgbToChannels;
+exports.rleDecode = rleDecode;
+exports.rleEncode = rleEncode;
 exports.round2digits = round2digits;
 exports.secondsToHm = secondsToHm;
 exports.set = set;
+exports.setLoggerLevel = setLoggerLevel;
 exports.shuffle = shuffle;
 exports.snakeCase = snakeCase;
 exports.sprintf = sprintf;