@adviser/cement 0.4.7 → 0.4.9

package/chunk-NTOGMD33.js

@@ -1,684 +0,0 @@
-var __defProp = Object.defineProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-
-// src/is-promise.ts
-function isPromise(a) {
-  const mayBe = a;
-  return mayBe instanceof Promise || !!(mayBe && mayBe !== null && typeof mayBe.then === "function" && typeof mayBe.catch === "function" && typeof mayBe.finally === "function");
-}
-
-// src/result.ts
-var Result = class _Result {
-  static Ok(t) {
-    return new ResultOK(t);
-  }
-  static Err(t) {
-    if (typeof t === "string") {
-      return new ResultError(new Error(t));
-    }
-    if (_Result.Is(t)) {
-      if (t.is_ok()) {
-        return new ResultError(new Error("Result Error is Ok"));
-      }
-      return t;
-    }
-    return new ResultError(t);
-  }
-  static Is(t) {
-    if (!t) {
-      return false;
-    }
-    if (t instanceof _Result) {
-      return true;
-    }
-    const rt = t;
-    if ([typeof rt.is_ok, typeof rt.is_err, typeof rt.unwrap, typeof rt.unwrap_err].every((x) => x === "function")) {
-      return true;
-    }
-    return false;
-  }
-  isOk() {
-    return this.is_ok();
-  }
-  isErr() {
-    return this.is_err();
-  }
-  Ok() {
-    return this.unwrap();
-  }
-  Err() {
-    return this.unwrap_err();
-  }
-};
-var ResultOK = class extends Result {
-  constructor(t) {
-    super();
-    this._t = t;
-  }
-  is_ok() {
-    return true;
-  }
-  is_err() {
-    return false;
-  }
-  unwrap_err() {
-    throw new Error("Result is Ok");
-  }
-  unwrap() {
-    return this._t;
-  }
-};
-var ResultError = class extends Result {
-  constructor(t) {
-    super();
-    this._error = t;
-  }
-  is_ok() {
-    return false;
-  }
-  is_err() {
-    return true;
-  }
-  unwrap() {
-    throw new Error(`Result is Err: ${this._error}`);
-  }
-  unwrap_err() {
-    return this._error;
-  }
-};
-function exception2Result(fn) {
-  try {
-    const res = fn();
-    if (isPromise(res)) {
-      return res.then((value) => Result.Ok(value)).catch((e) => Result.Err(e));
-    }
-    return Result.Ok(res);
-  } catch (e) {
-    return Result.Err(e);
-  }
-}
-
-// src/types.ts
-var _Required = class {
-  constructor() {
-    this.type = "REQUIRED";
-  }
-};
-var _Optional = class {
-  constructor() {
-    this.type = "OPTIONAL";
-  }
-};
-var param = {
-  REQUIRED: new _Required(),
-  OPTIONAL: new _Optional()
-};
-
-// src/utils/get-params-result.ts
-function getParamsResult(keys, getParam) {
-  const keyDef = keys.flat().reduce(
-    (acc, i) => {
-      if (typeof i === "string") {
-        acc.push({ key: i, def: void 0, isOptional: false });
-      } else if (typeof i === "object") {
-        acc.push(
-          ...Object.keys(i).map((k) => ({
-            key: k,
-            def: typeof i[k] === "string" ? i[k] : void 0,
-            isOptional: i[k] === param.OPTIONAL
-          }))
-        );
-      }
-      return acc;
-    },
-    []
-  );
-  const msgFn = keys.find((k) => typeof k === "function") || ((...keys2) => {
-    const msg = keys2.join(",");
-    return `missing parameters: ${msg}`;
-  });
-  const errors = [];
-  const result = {};
-  for (const kd of keyDef) {
-    const val = getParam.getParam(kd.key);
-    if (val === void 0) {
-      if (typeof kd.def === "string") {
-        result[kd.key] = kd.def;
-      } else {
-        if (!kd.isOptional) {
-          errors.push(kd.key);
-        }
-      }
-    } else {
-      result[kd.key] = val;
-    }
-  }
-  if (errors.length) {
-    return Result.Err(msgFn(...errors));
-  }
-  return Result.Ok(result);
-}
-
-// src/future.ts
-var _promise, _resolveFn, _rejectFn;
-var Future = class {
-  constructor() {
-    __privateAdd(this, _promise);
-    __privateAdd(this, _resolveFn, () => {
-      throw new Error("This Promise is not working as expected.");
-    });
-    __privateAdd(this, _rejectFn, () => {
-      throw new Error("This Promise is not working as expected.");
-    });
-    __privateSet(this, _promise, new Promise((resolve, reject) => {
-      __privateSet(this, _resolveFn, resolve);
-      __privateSet(this, _rejectFn, reject);
-    }));
-  }
-  async asPromise() {
-    return __privateGet(this, _promise);
-  }
-  resolve(value) {
-    __privateGet(this, _resolveFn).call(this, value);
-  }
-  reject(reason) {
-    __privateGet(this, _rejectFn).call(this, reason);
-  }
-};
-_promise = new WeakMap();
-_resolveFn = new WeakMap();
-_rejectFn = new WeakMap();
-
-// src/lru-map-set.ts
-var LRUSet = class {
-  constructor(param2 = {}) {
-    this._lruMap = new LRUMap(param2);
-  }
-  setParam(param2 = {}) {
-    this._lruMap.setParam(param2);
-  }
-  get size() {
-    return this._lruMap.size;
-  }
-  has(key) {
-    return this._lruMap.has(key);
-  }
-  add(key) {
-    this._lruMap.set(key, key);
-  }
-  delete(key) {
-    this._lruMap.delete(key);
-  }
-  clear() {
-    this._lruMap.clear();
-  }
-  forEach(callbackfn) {
-    this._lruMap.forEach((value) => callbackfn(value, value));
-  }
-  entries() {
-    return this._lruMap.entries();
-  }
-};
-var LRUMap = class {
-  constructor(c = {}) {
-    this._map = /* @__PURE__ */ new Map();
-    this.param = {
-      maxEntries: c.maxEntries || 100,
-      maxAge: c.maxAge || 0
-    };
-  }
-  touch(key) {
-    if (!this._map.has(key)) {
-      throw new Error(`key not found in cache: ${key}`);
-    }
-    const value = this._map.get(key);
-    this._map.delete(key);
-    this._map.set(key, value);
-    return value;
-  }
-  setParam(param2 = {}) {
-    if (typeof param2.maxEntries === "number") {
-      this.param.maxEntries = param2.maxEntries;
-      if (param2.maxEntries > 0 && this._map.size > param2.maxEntries) {
-        const toDelete = [];
-        let cacheSize = this._map.size;
-        for (const key of this._map.keys()) {
-          if (cacheSize > param2.maxEntries) {
-            toDelete.push(key);
-            cacheSize--;
-          } else {
-            break;
-          }
-        }
-        for (const key of toDelete) {
-          this._map.delete(key);
-        }
-      }
-    }
-  }
-  has(key) {
-    return this._map.has(key);
-  }
-  get size() {
-    return this._map.size;
-  }
-  async getSet(key, createFN) {
-    const val = this.get(key);
-    if (val) {
-      return val;
-    } else {
-      const val2 = await createFN(key);
-      this.set(key, val2);
-      return val2;
-    }
-  }
-  get(key) {
-    if (this._map.has(key)) {
-      return this.touch(key);
-    }
-    return this._map.get(key);
-  }
-  set(key, value) {
-    this._map.delete(key);
-    if (this.param.maxEntries > 0 && this._map.size >= this.param.maxEntries) {
-      this._map.delete(this._map.keys().next().value);
-      this._map.set(key, value);
-    } else {
-      this._map.set(key, value);
-    }
-  }
-  delete(key) {
-    this._map.delete(key);
-  }
-  clear() {
-    this._map.clear();
-  }
-  forEach(callbackfn) {
-    this._map.forEach(callbackfn);
-  }
-  entries() {
-    return this._map.entries();
-  }
-  // *entries(): IterableIterator<[T, K]> {
-  //   for (const x of this._cache.entries()) {
-  //     yield x;
-  //   }
-  // }
-  //   getLeastRecent(): K {
-  //     return Array.from(this.cache)[0];
-  //   }
-  //   getMostRecent(): K {
-  //     return Array.from(this.cache)[this.cache.size - 1];
-  //   }
-};
-
-// src/resolve-once.ts
-var ResolveSeq = class {
-  constructor(ctx) {
-    this._flushWaiting = [];
-    this._seqFutures = [];
-    this.ctx = ctx;
-  }
-  reset() {
-  }
-  flush() {
-    var _a;
-    if (this._seqFutures.length > 0) {
-      const waitForFlush = new Future();
-      (_a = this._flushWaiting) == null ? void 0 : _a.push(waitForFlush);
-      return waitForFlush.asPromise();
-    }
-    return Promise.resolve();
-  }
-  _step(item) {
-    var _a;
-    if (!item) {
-      this._flushWaiting.forEach((f) => f.resolve());
-      (_a = this._flushWaiting) == null ? void 0 : _a.splice(0, this._flushWaiting.length);
-      return Promise.resolve();
-    }
-    item.fn(this.ctx).then((value) => item.future.resolve(value)).catch((e) => item.future.reject(e)).finally(() => {
-      this._seqFutures.shift();
-      void this._step(this._seqFutures[0]);
-    });
-    return Promise.resolve();
-  }
-  async add(fn, id) {
-    const future = new Future();
-    this._seqFutures.push({ future, fn, id });
-    if (this._seqFutures.length === 1) {
-      void this._step(this._seqFutures[0]);
-    }
-    return future.asPromise();
-  }
-};
-var ResolveOnce = class {
-  constructor(ctx) {
-    this._onceDone = false;
-    this._onceFutures = [];
-    this._onceOk = false;
-    this._isPromise = false;
-    this.ctx = ctx;
-  }
-  get ready() {
-    return this._onceDone;
-  }
-  reset() {
-    this._onceDone = false;
-    this._onceOk = false;
-    this._onceValue = void 0;
-    this._onceError = void 0;
-    if (this._inProgress) {
-      const idx = this._onceFutures.findIndex((f) => f === this._inProgress);
-      if (idx >= 0) {
-        this._onceFutures.push(...this._onceFutures.splice(2).slice(1));
-      }
-    } else {
-      this._onceFutures.length = 0;
-    }
-  }
-  // T extends Option<infer U> ? U : T
-  once(fn) {
-    if (this._onceDone) {
-      if (this._onceError) {
-        if (this._isPromise) {
-          return Promise.reject(this._onceError);
-        } else {
-          throw this._onceError;
-        }
-      }
-      if (this._onceOk) {
-        if (this._isPromise) {
-          return Promise.resolve(this._onceValue);
-        } else {
-          return this._onceValue;
-        }
-      }
-      throw new Error("ResolveOnce.once impossible");
-    }
-    const future = new Future();
-    this._onceFutures.push(future);
-    if (this._onceFutures.length === 1) {
-      const okFn = (value) => {
-        this._onceValue = value;
-        this._onceOk = true;
-        this._onceDone = true;
-        if (this._isPromise) {
-          this._onceFutures.forEach((f) => f.resolve(this._onceValue));
-        }
-        this._onceFutures.length = 0;
-      };
-      const catchFn = (e) => {
-        this._onceError = e;
-        this._onceOk = false;
-        this._onceValue = void 0;
-        this._onceDone = true;
-        if (this._isPromise) {
-          this._onceFutures.forEach((f) => f.reject(this._onceError));
-        }
-        this._onceFutures.length = 0;
-      };
-      this._inProgress = future;
-      try {
-        const ret = fn(this.ctx);
-        if (typeof ret.then === "function") {
-          this._isPromise = true;
-          ret.then(okFn).catch(catchFn).finally(() => {
-            this._inProgress = void 0;
-          });
-        } else {
-          okFn(ret);
-        }
-      } catch (e) {
-        catchFn(e);
-      }
-      if (!this._isPromise) {
-        this._inProgress = void 0;
-      }
-    }
-    if (this._isPromise) {
-      return future.asPromise();
-    } else {
-      return this.once(fn);
-    }
-  }
-};
-var Keyed = class {
-  constructor(factory, params) {
-    var _a;
-    this.factory = factory;
-    this._map = new LRUMap((_a = params == null ? void 0 : params.lru) != null ? _a : { maxEntries: -1 });
-  }
-  setParam(params) {
-    this._map.setParam(params.lru);
-  }
-  async asyncGet(key) {
-    return this.get(await key());
-  }
-  get(key) {
-    if (typeof key === "function") {
-      key = key();
-    }
-    let keyed = this._map.get(key);
-    if (!keyed) {
-      keyed = this.factory(key);
-      this._map.set(key, keyed);
-    }
-    return keyed;
-  }
-  unget(key) {
-    const keyed = this._map.get(key);
-    keyed == null ? void 0 : keyed.reset();
-    this._map.delete(key);
-  }
-  reset() {
-    this._map.forEach((keyed) => keyed.reset());
-    this._map.clear();
-  }
-};
-var KeyedResolvOnce = class extends Keyed {
-  constructor(kp = {}) {
-    super((key) => new ResolveOnce(key), kp);
-  }
-  /**
-   *
-   * @returns The values of the resolved keys
-   */
-  values() {
-    return Array.from(this._map.entries()).filter(([_, v]) => v._onceDone).map(([k, v]) => {
-      if (v._onceDone) {
-        if (v._onceError) {
-          return {
-            key: k,
-            value: Result.Err(v._onceError)
-          };
-        }
-        return {
-          key: k,
-          value: Result.Ok(v._onceValue)
-        };
-      }
-      throw new Error("KeyedResolvOnce.values impossible");
-    });
-  }
-};
-var KeyedResolvSeq = class extends Keyed {
-  constructor(kp = {}) {
-    super((key) => new ResolveSeq(key), kp);
-  }
-};
-
-// src/utils/coerce-uint8.ts
-var globalBuffer = globalThis;
-function coerceIntoUint8(raw) {
-  if (raw instanceof ArrayBuffer) {
-    return Result.Ok(new Uint8Array(raw));
-  }
-  if (ArrayBuffer.isView(raw)) {
-    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
-  }
-  if (raw instanceof Blob) {
-    return Result.Err("Blob not supported");
-  }
-  if (globalBuffer.Buffer && globalBuffer.Buffer.isBuffer(raw)) {
-    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
-  }
-  if (raw instanceof Uint8Array) {
-    return Result.Ok(raw);
-  }
-  if (Result.Is(raw)) {
-    if (raw.isErr()) {
-      return Result.Err(raw);
-    }
-    return coerceIntoUint8(raw.unwrap());
-  }
-  return Result.Err("Not a Uint8Array");
-}
-async function asyncCoerceIntoUint8(raw) {
-  let resolved = await raw;
-  if (resolved instanceof Blob) {
-    resolved = await resolved.arrayBuffer();
-  }
-  return coerceIntoUint8(resolved);
-}
-
-// src/txt-en-decoder.ts
-var TxtOps = class {
-  constructor() {
-    this.encoder = new TextEncoder();
-    this.decoder = new TextDecoder();
-  }
-  encode(str) {
-    return this.encoder.encode(str);
-  }
-  decode(data) {
-    if (Result.Is(data)) {
-      if (data.isErr()) {
-        throw data.Err();
-      }
-      const unwrapped = data.unwrap();
-      if (typeof unwrapped === "string") {
-        return this.decode(unwrapped);
-      }
-    }
-    if (typeof data === "string") {
-      return data;
-    }
-    return this.decoder.decode(coerceIntoUint8(data).Ok());
-  }
-  async asyncDecode(data) {
-    let resolved = await data;
-    if (resolved instanceof Blob) {
-      resolved = await resolved.arrayBuffer();
-    }
-    return this.decode(resolved);
-  }
-};
-var txtEnDecoder = new ResolveOnce();
-function TxtEnDecoderSingleton() {
-  return txtEnDecoder.once(() => new TxtOps());
-}
-
-// src/utils/console-write-stream.ts
-var ConsoleWriterStreamDefaultWriter = class {
-  constructor(stream) {
-    this.stream = stream;
-    this.desiredSize = null;
-    this.decoder = new TextDecoder();
-    this._stream = stream;
-    this.ready = Promise.resolve(void 0);
-    this.closed = Promise.resolve(void 0);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
-  abort(reason) {
-    throw new Error("Method not implemented.");
-  }
-  async close() {
-  }
-  releaseLock() {
-    this._stream.locked = false;
-    this.ready = Promise.resolve(void 0);
-    this.closed = Promise.resolve(void 0);
-  }
-  write(chunk) {
-    let strObj = this.decoder.decode(chunk).trimEnd();
-    let output = "log";
-    try {
-      strObj = JSON.parse(strObj);
-      output = strObj.level;
-    } catch (e) {
-    }
-    switch (output) {
-      case "error":
-        console.error(strObj);
-        break;
-      case "warn":
-        console.warn(strObj);
-        break;
-      default:
-        console.log(strObj);
-    }
-    return Promise.resolve();
-  }
-};
-var ConsoleWriterStream = class {
-  constructor() {
-    this.locked = false;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
-  abort(reason) {
-    throw new Error("Method not implemented.");
-  }
-  close() {
-    return Promise.resolve();
-  }
-  getWriter() {
-    if (this.locked) {
-      throw new Error("Stream is locked");
-    }
-    this.locked = true;
-    if (!this._writer) {
-      this._writer = new ConsoleWriterStreamDefaultWriter(this);
-    }
-    return this._writer;
-  }
-};
-
-export {
-  __export,
-  __privateGet,
-  __privateAdd,
-  __privateMethod,
-  isPromise,
-  Result,
-  ResultOK,
-  ResultError,
-  exception2Result,
-  param,
-  getParamsResult,
-  Future,
-  LRUSet,
-  LRUMap,
-  ResolveSeq,
-  ResolveOnce,
-  Keyed,
-  KeyedResolvOnce,
-  KeyedResolvSeq,
-  coerceIntoUint8,
-  asyncCoerceIntoUint8,
-  TxtEnDecoderSingleton,
-  ConsoleWriterStreamDefaultWriter,
-  ConsoleWriterStream
-};
-//# sourceMappingURL=chunk-NTOGMD33.js.map