@adviser/cement 0.2.2 → 0.2.4

package/index.cjs

@@ -38,7 +38,6 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 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);
 var __await = function(promise, isYieldStar) {
   this[0] = promise;
   this[1] = isYieldStar;
@@ -75,6 +74,7 @@ var __yieldStar = (value) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  BrowserEnvActions: () => BrowserEnvActions,
   EnvImpl: () => EnvImpl,
   Future: () => Future,
   IDMode: () => IDMode,
@@ -85,6 +85,7 @@ __export(src_exports, {
   Level: () => Level,
   LevelHandlerImpl: () => LevelHandlerImpl,
   LogCollector: () => LogCollector,
+  LogValue: () => LogValue,
   LogWriter: () => LogWriter,
   LoggerImpl: () => LoggerImpl,
   MockLogger: () => MockLogger,
@@ -101,7 +102,9 @@ __export(src_exports, {
   Time: () => Time,
   TimeMode: () => TimeMode,
   TimeUnits: () => TimeUnits,
-  envImpl: () => envImpl
+  envFactory: () => envFactory,
+  logValue: () => logValue,
+  removeSelfRef: () => removeSelfRef
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -113,6 +116,46 @@ var Level = /* @__PURE__ */ ((Level2) => {
   Level2["ERROR"] = "error";
   return Level2;
 })(Level || {});
+var LogValue = class {
+  constructor(fn) {
+    this.fn = fn;
+  }
+  value() {
+    return this.fn();
+  }
+  toJSON() {
+    return this.value();
+  }
+};
+function removeSelfRef() {
+  const cache = /* @__PURE__ */ new Set();
+  return function(key, value) {
+    if (typeof value === "object" && value !== null) {
+      if (cache.has(value)) return "...";
+      cache.add(value);
+    }
+    return value;
+  };
+}
+function logValue(val) {
+  switch (typeof val) {
+    case "function":
+      return new LogValue(val);
+    case "string":
+      return new LogValue(() => val.toString());
+    case "number":
+      return new LogValue(() => val);
+    case "boolean":
+      return new LogValue(() => val);
+    case "object":
+      return new LogValue(() => JSON.parse(JSON.stringify(val, removeSelfRef())));
+    default:
+      if (!val) {
+        return new LogValue(() => "--Falsy--");
+      }
+      throw new Error(`Invalid type:${typeof val}`);
+  }
+}
 function IsLogger(obj) {
   return typeof obj === "object" && [
     "Module",
@@ -356,170 +399,339 @@ var WrapperSysAbstraction = class {
   }
 };
 
+// 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/resolve-once.ts
+var ResolveSeq = class {
+  constructor(ctx) {
+    this._seqFutures = [];
+    this.ctx = ctx;
+  }
+  reset() {
+  }
+  async _step(item) {
+    if (!item) {
+      return;
+    }
+    item.fn(this.ctx).then((value) => item.future.resolve(value)).catch((e) => item.future.reject(e)).finally(() => this._step(this._seqFutures.shift()));
+  }
+  async add(fn) {
+    const future = new Future();
+    this._seqFutures.push({ future, fn });
+    this._step(this._seqFutures.shift());
+    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;
+    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;
+      };
+      try {
+        const ret = fn(this.ctx);
+        if (typeof ret.then === "function") {
+          this._isPromise = true;
+          ret.then(okFn).catch(catchFn);
+        } else {
+          okFn(ret);
+        }
+      } catch (e) {
+        catchFn(e);
+      }
+    }
+    if (this._isPromise) {
+      return future.asPromise();
+    } else {
+      return this.once(fn);
+    }
+  }
+};
+var Keyed = class {
+  constructor(factory) {
+    this._map = /* @__PURE__ */ new Map();
+    this.factory = factory;
+  }
+  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;
+  }
+  reset() {
+    this._map.forEach((keyed) => keyed.reset());
+    this._map.clear();
+  }
+};
+var KeyedResolvOnce = class extends Keyed {
+  constructor() {
+    super((key) => new ResolveOnce(key));
+  }
+};
+var KeyedResolvSeq = class extends Keyed {
+  constructor() {
+    super((key) => new ResolveSeq(key));
+  }
+};
+
 // src/sys_env.ts
-var _node, _env;
+var _node;
 var NodeEnvActions = class {
   // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
   constructor(opts) {
     __privateAdd(this, _node, globalThis);
-    __privateAdd(this, _env, this.use() ? process.env : {});
+    this._env = this.active() ? __privateGet(this, _node).process.env : {};
+  }
+  register(env) {
+    return env;
   }
-  use() {
+  active() {
     return typeof __privateGet(this, _node) === "object" && typeof __privateGet(this, _node).process === "object" && typeof __privateGet(this, _node).process.env === "object";
   }
   keys() {
-    return Object.keys(__privateGet(this, _env));
+    return Object.keys(this._env);
   }
   get(key) {
-    return __privateGet(this, _env)[key];
+    return this._env[key];
   }
   set(key, value) {
     if (value) {
-      __privateGet(this, _env)[key] = value;
+      this._env[key] = value;
     }
   }
-  del(key) {
-    delete __privateGet(this, _env)[key];
+  delete(key) {
+    delete this._env[key];
   }
 };
 _node = new WeakMap();
-_env = new WeakMap();
-var _deno, _env2;
+var _deno;
 var DenoEnvActions = class {
-  constructor(opts, env) {
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
+  constructor(opts) {
     __privateAdd(this, _deno, globalThis);
-    __privateAdd(this, _env2);
-    if (env) {
-      __privateSet(this, _env2, env);
-    } else {
-      __privateSet(this, _env2, this.use() ? __privateGet(this, _deno).Deno.env : /* @__PURE__ */ new Map());
-    }
   }
-  use() {
+  get _env() {
+    return __privateGet(this, _deno).Deno.env;
+  }
+  register(env) {
+    return env;
+  }
+  active() {
     return typeof __privateGet(this, _deno) === "object" && typeof __privateGet(this, _deno).Deno === "object" && typeof __privateGet(this, _deno).Deno.env === "object";
   }
   keys() {
-    return Array.from(__privateGet(this, _env2).keys());
+    return Array.from(this._env.keys());
   }
   get(key) {
-    return __privateGet(this, _env2).get(key);
+    return this._env.get(key);
   }
   set(key, value) {
     if (value) {
-      __privateGet(this, _env2).set(key, value);
+      this._env.set(key, value);
     }
   }
-  del(key) {
-    __privateGet(this, _env2).delete(key);
+  delete(key) {
+    this._env.delete(key);
   }
 };
 _deno = new WeakMap();
-_env2 = new WeakMap();
-var BrowserEnvActions = class _BrowserEnvActions extends DenoEnvActions {
-  static globalBEA(sym) {
-    const browser = globalThis;
-    if (typeof browser === "object" && typeof browser[sym] === "object") {
-      return { map: browser[sym]._map, finalize: () => browser[sym]._map };
+var BrowserEnvActions = class {
+  constructor(opts) {
+    this.env = /* @__PURE__ */ new Map();
+    this.opts = opts;
+  }
+  get(key) {
+    return this.env.get(key);
+  }
+  set(key, value) {
+    if (value) {
+      this.env.set(key, value);
     }
-    const map = /* @__PURE__ */ new Map();
-    return {
-      map,
-      finalize: (bea) => {
-        browser[sym] = bea;
-        return map;
-      }
-    };
   }
-  constructor(opts) {
-    const { map, finalize } = _BrowserEnvActions.globalBEA(Symbol.for(opts.symbol || "CP_ENV"));
-    super(opts, map);
-    this._map = finalize(this);
+  delete(key) {
+    this.env.delete(key);
   }
-  use() {
+  keys() {
+    return Array.from(this.env.keys());
+  }
+  active() {
     return true;
   }
+  register(env) {
+    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
+    const browser = globalThis;
+    browser[sym] = env;
+    return env;
+  }
 };
+var _envFactory = new ResolveOnce();
 function envFactory(opts = {}) {
-  const found = [new NodeEnvActions(opts), new DenoEnvActions(opts), new BrowserEnvActions(opts)].find((env) => env.use());
-  if (!found) {
-    throw new Error("SysContainer:envFactory: no env available");
-  }
-  return found;
+  return _envFactory.once(() => {
+    const found = [new NodeEnvActions(opts), new DenoEnvActions(opts), new BrowserEnvActions(opts)].find((env) => env.active());
+    if (!found) {
+      throw new Error("SysContainer:envFactory: no env available");
+    }
+    const ret = new EnvImpl(found, opts);
+    found.register(ret);
+    return ret;
+  });
 }
-var _envImpl, _EnvImpl_instances, updatePresets_fn, applyOnSet_fn, _onSet;
 var EnvImpl = class {
-  constructor(opts = {}) {
-    __privateAdd(this, _EnvImpl_instances);
-    __privateAdd(this, _envImpl);
-    __privateAdd(this, _onSet, []);
-    __privateSet(this, _envImpl, envFactory(opts));
-    __privateMethod(this, _EnvImpl_instances, updatePresets_fn).call(this, opts.presetEnv);
+  constructor(map, opts = {}) {
+    this._onSet = [];
+    this._map = map;
+    this._updatePresets(opts.presetEnv);
+  }
+  _updatePresets(presetEnv) {
+    if (!presetEnv) {
+      return;
+    }
+    for (const [key, value] of presetEnv) {
+      this._map.set(key, value);
+    }
+  }
+  _applyOnSet(onSet, key, value) {
+    onSet.forEach((item) => {
+      let keys = [];
+      if (key) {
+        keys = [key];
+      } else {
+        keys = this._map.keys();
+      }
+      keys.filter((k) => {
+        if (item.filter.size === 0) {
+          return true;
+        }
+        if (item.filter.has(k)) {
+          return true;
+        }
+        return false;
+      }).forEach((k) => {
+        let v;
+        if (!key && !value) {
+          v = this._map.get(k);
+        } else if (key && !value) {
+          v = void 0;
+        } else {
+          v = value;
+        }
+        item.fn(k, v);
+      });
+    });
   }
   keys() {
-    return __privateGet(this, _envImpl).keys();
+    return this._map.keys();
   }
   // filter is not set all sets passed
   onSet(fn, ...filter) {
     const item = { filter: new Set(filter), fn };
-    __privateGet(this, _onSet).push(item);
-    __privateMethod(this, _EnvImpl_instances, applyOnSet_fn).call(this, [item]);
+    this._onSet.push(item);
+    this._applyOnSet([item]);
   }
   get(key) {
-    return __privateGet(this, _envImpl).get(key);
+    return this._map.get(key);
   }
   set(key, value) {
     if (!value) {
       return;
     }
-    __privateGet(this, _envImpl).set(key, value);
-    __privateMethod(this, _EnvImpl_instances, applyOnSet_fn).call(this, __privateGet(this, _onSet), key, value);
-  }
-  del(key) {
-    __privateGet(this, _envImpl).del(key);
-    __privateMethod(this, _EnvImpl_instances, applyOnSet_fn).call(this, __privateGet(this, _onSet), key);
-  }
-};
-_envImpl = new WeakMap();
-_EnvImpl_instances = new WeakSet();
-updatePresets_fn = function(presetEnv) {
-  if (!presetEnv) {
-    return;
+    this._map.set(key, value);
+    this._applyOnSet(this._onSet, key, value);
   }
-  for (const [key, value] of presetEnv) {
-    __privateGet(this, _envImpl).set(key, value);
+  delete(key) {
+    this._map.delete(key);
+    this._applyOnSet(this._onSet, key);
   }
 };
-applyOnSet_fn = function(onSet, key, value) {
-  onSet.forEach((item) => {
-    let keys = [];
-    if (key) {
-      keys = [key];
-    } else {
-      keys = __privateGet(this, _envImpl).keys();
-    }
-    keys.filter((k) => {
-      if (item.filter.size === 0) {
-        return true;
-      }
-      if (item.filter.has(k)) {
-        return true;
-      }
-      return false;
-    }).forEach((k) => {
-      let v;
-      if (!key && !value) {
-        v = __privateGet(this, _envImpl).get(k);
-      } else if (key && !value) {
-        v = void 0;
-      } else {
-        v = value;
-      }
-      item.fn(k, v);
-    });
-  });
-};
-_onSet = new WeakMap();
-var envImpl = new EnvImpl();
 
 // src/web/web_sys_abstraction.ts
 var WebFileService = class {
@@ -569,7 +781,7 @@ var WebFileService = class {
 };
 var WebSystemService = class {
   Env() {
-    return envImpl;
+    return envFactory();
   }
   Args() {
     throw new Error("Args-Method not implemented.");
@@ -596,43 +808,6 @@ function WebSysAbstraction(param) {
 
 // src/logger_impl.ts
 var encoder = new TextEncoder();
-var LogValue = class {
-  constructor(fn) {
-    this.fn = fn;
-  }
-  value() {
-    return this.fn();
-  }
-};
-function resolveLogValue(val) {
-  const ret = {};
-  Object.keys(val).forEach((key) => {
-    const v = val[key];
-    if (v instanceof LogValue) {
-      ret[key] = v.value();
-    }
-  });
-  return ret;
-}
-function logValue(val) {
-  switch (typeof val) {
-    case "function":
-      return new LogValue(val);
-    case "string":
-      return new LogValue(() => val.toString());
-    case "number":
-      return new LogValue(() => val);
-    case "boolean":
-      return new LogValue(() => val);
-    case "object":
-      return new LogValue(() => JSON.stringify(val));
-    default:
-      if (!val) {
-        return new LogValue(() => "--Falsy--");
-      }
-      throw new Error(`Invalid type:${typeof val}`);
-  }
-}
 var LevelHandlerImpl = class {
   constructor() {
     this._globalLevels = /* @__PURE__ */ new Set(["info" /* INFO */, "error" /* ERROR */, "warn" /* WARN */]);
@@ -928,7 +1103,7 @@ var LoggerImpl = class _LoggerImpl {
         _attributes: attr
       });
     }
-    return JSON.stringify(resolveLogValue(attr));
+    return JSON.stringify(attr, removeSelfRef());
   }
   Msg(...args) {
     const fnError = this._resetAttributes(() => {
@@ -936,7 +1111,7 @@ var LoggerImpl = class _LoggerImpl {
       const doWrite = this._levelHandler.isEnabled((_a = this._attributes["level"]) == null ? void 0 : _a.value(), (_b = this._attributes["module"]) == null ? void 0 : _b.value());
       let fnRet = () => this._produceError(__spreadValues({}, this._attributes), ...args);
       if (doWrite) {
-        const str = this._produceError(__spreadValues({}, this._attributes), ...args);
+        const str = fnRet();
         const encoded = encoder.encode(str + "\n");
         this._logWriter.write(encoded);
         fnRet = () => str;
@@ -1149,7 +1324,17 @@ var Result = class _Result {
     return new ResultError(t);
   }
   static Is(t) {
-    return t instanceof _Result;
+    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();
@@ -1248,142 +1433,9 @@ var None = class extends Option {
     throw new Error("None.unwrap");
   }
 };
-
-// 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/resolve-once.ts
-var ResolveSeq = class {
-  constructor(ctx) {
-    this._seqFutures = [];
-    this.ctx = ctx;
-  }
-  reset() {
-  }
-  async _step(item) {
-    if (!item) {
-      return;
-    }
-    item.fn(this.ctx).then((value) => item.future.resolve(value)).catch((e) => item.future.reject(e)).finally(() => this._step(this._seqFutures.shift()));
-  }
-  async add(fn) {
-    const future = new Future();
-    this._seqFutures.push({ future, fn });
-    this._step(this._seqFutures.shift());
-    return future.asPromise();
-  }
-};
-var ResolveOnce = class {
-  constructor(ctx) {
-    this._onceDone = false;
-    this._onceFutures = [];
-    this._onceOk = false;
-    this.ctx = ctx;
-  }
-  get ready() {
-    return this._onceDone;
-  }
-  reset() {
-    this._onceDone = false;
-    this._onceOk = false;
-    this._onceValue = void 0;
-    this._onceError = void 0;
-    this._onceFutures.length = 0;
-  }
-  async once(fn) {
-    if (this._onceDone) {
-      if (this._onceError) {
-        return Promise.reject(this._onceError);
-      }
-      if (this._onceOk) {
-        return Promise.resolve(this._onceValue);
-      }
-      throw new Error("ResolveOnce.once impossible");
-    }
-    const future = new Future();
-    this._onceFutures.push(future);
-    if (this._onceFutures.length === 1) {
-      fn(this.ctx).then((value) => {
-        this._onceValue = value;
-        this._onceOk = true;
-        this._onceDone = true;
-        this._onceFutures.forEach((f) => f.resolve(this._onceValue));
-        this._onceFutures.length = 0;
-      }).catch((e) => {
-        this._onceError = e;
-        this._onceOk = false;
-        this._onceValue = void 0;
-        this._onceDone = true;
-        this._onceFutures.forEach((f) => f.reject(this._onceError));
-        this._onceFutures.length = 0;
-      });
-    }
-    return future.asPromise();
-  }
-};
-var Keyed = class {
-  constructor(factory) {
-    this._map = /* @__PURE__ */ new Map();
-    this.factory = factory;
-  }
-  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;
-  }
-  reset() {
-    this._map.forEach((keyed) => keyed.reset());
-    this._map.clear();
-  }
-};
-var KeyedResolvOnce = class extends Keyed {
-  constructor() {
-    super((key) => new ResolveOnce(key));
-  }
-};
-var KeyedResolvSeq = class extends Keyed {
-  constructor() {
-    super((key) => new ResolveSeq(key));
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BrowserEnvActions,
   EnvImpl,
   Future,
   IDMode,
@@ -1394,6 +1446,7 @@ var KeyedResolvSeq = class extends Keyed {
   Level,
   LevelHandlerImpl,
   LogCollector,
+  LogValue,
   LogWriter,
   LoggerImpl,
   MockLogger,
@@ -1410,6 +1463,8 @@ var KeyedResolvSeq = class extends Keyed {
   Time,
   TimeMode,
   TimeUnits,
-  envImpl
+  envFactory,
+  logValue,
+  removeSelfRef
 });
 //# sourceMappingURL=index.cjs.map