@adviser/cement 0.4.7 → 0.4.9

package/chunk-FURW5CDL.js

@@ -1,792 +0,0 @@
-import {
-  ConsoleWriterStream,
-  KeyedResolvOnce,
-  ResolveOnce,
-  TxtEnDecoderSingleton,
-  __privateAdd,
-  __privateGet,
-  getParamsResult
-} from "./chunk-NTOGMD33.js";
-
-// src/runtime.ts
-function isSet(value, ref = globalThis) {
-  const [head, ...tail] = value.split(".");
-  if (["object", "function"].includes(typeof ref) && ref && ["object", "function"].includes(typeof ref[head]) && ref[head]) {
-    if (tail.length <= 1) {
-      return true;
-    }
-    return isSet(tail.join("."), ref[head]);
-  }
-  return false;
-}
-function runtimeFn() {
-  const gt = globalThis;
-  let isReactNative = (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    isSet("navigator.product") && typeof gt["navigator"] === "object" && gt["navigator"]["product"] === "ReactNative"
-  );
-  let isNodeIsh = false;
-  if (!isSet("Deno")) {
-    isNodeIsh = isSet("process.versions.node") && !isReactNative;
-  }
-  let isDeno = isSet("Deno");
-  const isCFWorker = isSet("caches.default") && isSet("WebSocketPair");
-  if (isCFWorker) {
-    isDeno = false;
-    isNodeIsh = false;
-    isReactNative = false;
-  }
-  return {
-    isNodeIsh,
-    isBrowser: !(isNodeIsh || isDeno || isCFWorker || isReactNative),
-    isDeno,
-    isReactNative,
-    isCFWorker
-  };
-}
-
-// src/sys-abstraction.ts
-var TimeMode = {
-  REAL: "real",
-  CONST: "const",
-  STEP: "step"
-};
-var RandomMode = {
-  CONST: "const",
-  STEP: "step",
-  RANDOM: "random"
-};
-var IDMode = {
-  UUID: "uuid",
-  CONST: "const",
-  STEP: "step"
-};
-function String2TimeMode(s) {
-  switch (s == null ? void 0 : s.toLowerCase()) {
-    case "real":
-      return TimeMode.REAL;
-    case "const":
-      return TimeMode.CONST;
-    case "step":
-      return TimeMode.STEP;
-    default:
-      return TimeMode.REAL;
-  }
-}
-
-// src/time.ts
-var Time = class {
-  TimeSince(start) {
-    const now = this.Now();
-    return now.getTime() - start.getTime();
-  }
-};
-var TimeUnits = {
-  Microsecond: 1,
-  Second: 1e3 * 1,
-  //Microsecond,
-  Minute: 60 * 1e3 * 1,
-  //Second,
-  Hour: 60 * 60 * 1e3 * 1
-  // Minute,
-};
-
-// src/cf/cf-env-actions.ts
-var once = new ResolveOnce();
-var CFEnvActions = class _CFEnvActions {
-  constructor(env) {
-    this.injectOnRegister = {};
-    this.cfEnv = new Map(Object.entries(env.presetEnv || {}));
-  }
-  static new(opts) {
-    return once.once(() => new _CFEnvActions(opts));
-  }
-  static inject(o) {
-    const env = _CFEnvActions.new({});
-    for (const key in o) {
-      const value = o[key];
-      if (typeof value === "string") {
-        if (env.env) {
-          env.env.set(key, value);
-        } else {
-          env.injectOnRegister[key] = value;
-        }
-      }
-    }
-  }
-  active() {
-    return runtimeFn().isCFWorker;
-  }
-  register(env) {
-    this.env = env;
-    for (const key in this.injectOnRegister) {
-      env.set(key, this.injectOnRegister[key]);
-    }
-    return env;
-  }
-  get(key) {
-    return this.cfEnv.get(key);
-  }
-  set(key, value) {
-    if (value) {
-      this.cfEnv.set(key, value);
-    }
-  }
-  delete(key) {
-    this.cfEnv.delete(key);
-  }
-  keys() {
-    return Array.from(this.cfEnv.keys());
-  }
-};
-
-// src/deno/deno-env-actions.ts
-var once2 = new ResolveOnce();
-var _deno;
-var _DenoEnvActions = class _DenoEnvActions {
-  constructor(opts) {
-    __privateAdd(this, _deno, globalThis);
-    this.opts = opts;
-  }
-  static new(opts) {
-    return once2.once(() => new _DenoEnvActions(opts));
-  }
-  get _env() {
-    return __privateGet(this, _deno).Deno.env;
-  }
-  register(env) {
-    for (const key of env.keys()) {
-      this._env.set(key, env.get(key) || "");
-    }
-    return env;
-  }
-  active() {
-    return runtimeFn().isDeno;
-  }
-  keys() {
-    return Object.keys(this._env.toObject());
-  }
-  get(key) {
-    return this._env.get(key);
-  }
-  set(key, value) {
-    if (value) {
-      this._env.set(key, value);
-    }
-  }
-  delete(key) {
-    this._env.delete(key);
-  }
-};
-_deno = new WeakMap();
-var DenoEnvActions = _DenoEnvActions;
-
-// src/node/node-env-actions.ts
-var once3 = new ResolveOnce();
-var _node;
-var _NodeEnvActions = class _NodeEnvActions {
-  constructor(opts) {
-    __privateAdd(this, _node, globalThis);
-    this._env = this.active() ? __privateGet(this, _node).process.env : {};
-    this.opts = opts;
-  }
-  static new(opts) {
-    return once3.once(() => new _NodeEnvActions(opts));
-  }
-  register(env) {
-    for (const key of env.keys()) {
-      this._env[key] = env.get(key) || "";
-    }
-    return env;
-  }
-  active() {
-    return runtimeFn().isNodeIsh;
-  }
-  keys() {
-    return Object.keys(this._env);
-  }
-  get(key) {
-    return this._env[key];
-  }
-  set(key, value) {
-    if (value) {
-      this._env[key] = value;
-    }
-  }
-  delete(key) {
-    delete this._env[key];
-  }
-};
-_node = new WeakMap();
-var NodeEnvActions = _NodeEnvActions;
-
-// src/web/web-env-actions.ts
-var once4 = new ResolveOnce();
-var BrowserEnvActions = class _BrowserEnvActions {
-  constructor(opts) {
-    this.env = /* @__PURE__ */ new Map();
-    this.opts = opts;
-  }
-  static new(opts) {
-    return once4.once(() => new _BrowserEnvActions(opts));
-  }
-  get(key) {
-    return this.env.get(key);
-  }
-  set(key, value) {
-    if (value) {
-      this.env.set(key, value);
-    }
-  }
-  delete(key) {
-    this.env.delete(key);
-  }
-  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;
-  }
-};
-
-// src/sys-env.ts
-var envActions = [
-  { id: "cf", fn: (opts) => CFEnvActions.new(opts) },
-  { id: "node", fn: (opts) => NodeEnvActions.new(opts) },
-  { id: "deno", fn: (opts) => DenoEnvActions.new(opts) },
-  { id: "browser", fn: (opts) => BrowserEnvActions.new(opts) }
-];
-function registerEnvAction(fn) {
-  const id = `id-${Math.random()}`;
-  envActions.unshift({ id, fn });
-  _envFactories.unget(id);
-  return () => {
-    const index = envActions.findIndex((i) => i.id === id);
-    if (index >= 0) {
-      envActions.splice(index, 1);
-    }
-  };
-}
-var _envFactories = new KeyedResolvOnce();
-function envFactory(opts = {}) {
-  const found = envActions.find((fi) => fi.fn(opts).active());
-  if (!found) {
-    throw new Error("SysContainer:envFactory: no env available");
-  }
-  return _envFactories.get(found.id).once(() => {
-    const action = found.fn(opts);
-    const ret = new EnvImpl(action, opts);
-    action.register(ret);
-    return ret;
-  });
-}
-function isIterable(obj) {
-  if (obj == null) {
-    return false;
-  }
-  return typeof obj[Symbol.iterator] === "function";
-}
-var EnvImpl = class {
-  constructor(map, opts = {}) {
-    this._onSet = [];
-    this._map = map;
-    this._updatePresets(opts.presetEnv);
-  }
-  gets(...kparams) {
-    return getParamsResult(kparams, {
-      getParam: (k) => this.get(k)
-    });
-  }
-  sets(...keys) {
-    keys.forEach((key) => {
-      if (Array.isArray(key)) {
-        if (key.length === 2) {
-          const [k, v] = key;
-          if (typeof k === "string" && typeof v === "string") {
-            this.set(k, v);
-            return;
-          }
-        }
-        for (const item of key) {
-          if (Array.isArray(item)) {
-            if (item.length === 2) {
-              const [k, v] = item;
-              if (typeof k === "string" && typeof v === "string") {
-                this.set(k, v);
-              }
-            }
-          }
-        }
-      } else {
-        if (isIterable(key)) {
-          for (const [k, v] of key) {
-            if (typeof k === "string" && typeof v === "string") {
-              this.set(k, v);
-            }
-          }
-        } else {
-          const rKey = key;
-          for (const k in rKey) {
-            const v = rKey[k];
-            if (typeof k === "string" && typeof v === "string") {
-              this.set(k, v);
-            }
-          }
-        }
-      }
-    });
-  }
-  _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 this._map.keys();
-  }
-  // filter is not set all sets passed
-  onSet(fn, ...filter) {
-    const item = { filter: new Set(filter), fn };
-    this._onSet.push(item);
-    this._applyOnSet([item]);
-  }
-  get(key) {
-    return this._map.get(key);
-  }
-  set(key, value) {
-    if (!value) {
-      return;
-    }
-    this._map.set(key, value);
-    this._applyOnSet(this._onSet, key, value);
-  }
-  delete(key) {
-    this._map.delete(key);
-    this._applyOnSet(this._onSet, key);
-  }
-};
-
-// src/cf/cf-basic-sys-abstraction.ts
-var CFRuntimeService = class {
-  constructor(ende) {
-    this._txtEnDe = ende;
-  }
-  Env() {
-    return envFactory();
-  }
-  Args() {
-    throw new Error("Args-Method not implemented.");
-  }
-  Stdout() {
-    return CFWriteableStream((chunk) => {
-      const decoded = this._txtEnDe.decode(chunk);
-      console.log(decoded.trimEnd());
-      return Promise.resolve();
-    });
-  }
-  Stderr() {
-    return CFWriteableStream((chunk) => {
-      const decoded = this._txtEnDe.decode(chunk);
-      console.error(decoded.trimEnd());
-      return Promise.resolve();
-    });
-  }
-};
-function consumeReadableStream(reader, writeFn) {
-  reader.read().then(({ done, value }) => {
-    if (done) {
-      return;
-    }
-    writeFn(value).then(() => {
-      consumeReadableStream(reader, writeFn);
-    }).catch((e) => {
-      console.error("consumeReadableStream:writeFn", e);
-    });
-  }).catch((e) => {
-    console.error("consumeReadableStream:read", e);
-  });
-}
-function CFWriteableStream(writeFn) {
-  const ts = new TransformStream();
-  consumeReadableStream(ts.readable.getReader(), writeFn);
-  return ts.writable;
-}
-var baseSysAbstraction = new ResolveOnce();
-function CFBasicSysAbstraction(param) {
-  var _a;
-  const my = baseSysAbstraction.once(() => {
-    return new BaseBasicSysAbstraction({
-      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || TxtEnDecoderSingleton()
-    });
-  });
-  return new WrapperBasicSysAbstraction(my, {
-    basicRuntimeService: new CFRuntimeService((_a = param == null ? void 0 : param.TxtEnDecoder) != null ? _a : my._txtEnDe),
-    ...param
-  });
-}
-
-// src/deno/deno-basic-sys-abstraction.ts
-var DenoRuntimeService = class {
-  constructor(ende) {
-    this._txtEnDe = ende;
-  }
-  Env() {
-    return envFactory();
-  }
-  Args() {
-    return globalThis.Deno.args;
-  }
-  Stdout() {
-    return globalThis.Deno.stdout.writable;
-  }
-  Stderr() {
-    return globalThis.Deno.stderr.writable;
-  }
-};
-var baseSysAbstraction2 = new ResolveOnce();
-function DenoBasicSysAbstraction(param) {
-  var _a;
-  const my = baseSysAbstraction2.once(() => {
-    return new BaseBasicSysAbstraction({
-      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || TxtEnDecoderSingleton()
-    });
-  });
-  return new WrapperBasicSysAbstraction(my, {
-    basicRuntimeService: new DenoRuntimeService((_a = param == null ? void 0 : param.TxtEnDecoder) != null ? _a : my._txtEnDe),
-    ...param
-  });
-}
-
-// src/node/node-basic-sys-abstraction.ts
-var NodeRuntimeService = class {
-  constructor(ende) {
-    this._txtEnDe = ende;
-    this._gthis = globalThis;
-  }
-  Env() {
-    return envFactory();
-  }
-  Args() {
-    return this._gthis.process.argv;
-  }
-  Stdout() {
-    return new WritableStream({
-      write: (chunk) => {
-        this._gthis.process.stdout.write(chunk);
-      }
-    });
-  }
-  Stderr() {
-    return new WritableStream({
-      write: (chunk) => {
-        this._gthis.process.stderr.write(chunk);
-      }
-    });
-  }
-};
-var baseSysAbstraction3 = new ResolveOnce();
-function NodeBasicSysAbstraction(param) {
-  var _a;
-  const my = baseSysAbstraction3.once(() => {
-    return new BaseBasicSysAbstraction({
-      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || TxtEnDecoderSingleton()
-    });
-  });
-  return new WrapperBasicSysAbstraction(my, {
-    basicRuntimeService: new NodeRuntimeService((_a = param == null ? void 0 : param.TxtEnDecoder) != null ? _a : my._txtEnDe),
-    ...param
-  });
-}
-
-// src/base-sys-abstraction.ts
-var SysTime = class extends Time {
-  Now() {
-    return /* @__PURE__ */ new Date();
-  }
-  Sleep(duration) {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve();
-      }, duration);
-    });
-  }
-};
-var ConstTime = class extends Time {
-  Now() {
-    return new Date(2021, 1, 1, 0, 0, 0, 0);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  Sleep(duration) {
-    return Promise.resolve();
-  }
-};
-var StepTime = class extends Time {
-  constructor() {
-    super();
-    this._step = new ConstTime().Now();
-    this._start = this._step;
-  }
-  Now(steps = 1) {
-    for (let i = 0; steps > 0 && i < steps; i++) {
-      this._step = new Date(this._step.getTime() + 1e3);
-    }
-    if (steps < 1) {
-      this._step = new Date(this._start.getTime() + steps * -1e3);
-    }
-    return this._step;
-  }
-  Sleep(duration) {
-    this._step = new Date(this._step.getTime() + duration);
-    return Promise.resolve();
-  }
-};
-function TimeFactory(timeMode) {
-  switch (timeMode) {
-    case TimeMode.REAL:
-      return new SysTime();
-    case TimeMode.CONST:
-      return new ConstTime();
-    case TimeMode.STEP:
-      return new StepTime();
-  }
-  return new SysTime();
-}
-var RandomService = class {
-  constructor(mode) {
-    this._step = 0;
-    this._mode = mode;
-  }
-  Random0ToValue(value) {
-    switch (this._mode) {
-      case RandomMode.CONST:
-        return 0.5 * value;
-      case RandomMode.STEP:
-        this._step += 1e-4;
-        return this._step * value;
-      case RandomMode.RANDOM:
-        return Math.random() * value;
-      default:
-        throw new Error("Unknown RandomMode");
-    }
-  }
-};
-var IdService = class {
-  constructor(mode) {
-    this._step = 0;
-    if (!mode) {
-      mode = IDMode.UUID;
-    }
-    this._mode = mode;
-  }
-  NextId() {
-    switch (this._mode) {
-      case IDMode.UUID:
-        return crypto.randomUUID();
-      case IDMode.CONST:
-        return "VeryUniqueID";
-      case IDMode.STEP:
-        return `STEPId-${this._step++}`;
-      default:
-        throw new Error("Unknown IDMode");
-    }
-  }
-};
-var BaseBasicSysAbstraction = class {
-  constructor(params) {
-    this._time = new SysTime();
-    // system independent services
-    this._idService = new IdService();
-    this._randomService = new RandomService(RandomMode.RANDOM);
-    this._txtEnDe = params.TxtEnDecoder;
-  }
-};
-var BaseSysAbstraction = class extends BaseBasicSysAbstraction {
-  constructor(params) {
-    super(params);
-    this._fileSystem = params.FileSystem;
-    this._systemService = params.SystemService;
-  }
-};
-function BasicSysAbstractionFactory(params) {
-  const fn = runtimeFn();
-  switch (true) {
-    case fn.isBrowser:
-      return WebBasicSysAbstraction(params);
-    case fn.isDeno:
-      return DenoBasicSysAbstraction(params);
-    case fn.isCFWorker:
-      return CFBasicSysAbstraction(params);
-    case fn.isNodeIsh:
-      return NodeBasicSysAbstraction(params);
-    default:
-      throw new Error("Unknown runtime");
-  }
-}
-var WrapperBasicSysAbstraction = class {
-  constructor(base, params) {
-    this._time = base._time;
-    this._basicRuntimeService = params.basicRuntimeService;
-    this._idService = base._idService;
-    this._randomService = base._randomService;
-    if (params.TimeMode) {
-      this._time = TimeFactory(params.TimeMode);
-    }
-    if (params.IdMode) {
-      this._idService = new IdService(params.IdMode);
-    }
-    if (params.RandomMode) {
-      this._randomService = new RandomService(params.RandomMode);
-    }
-  }
-  Time() {
-    return this._time;
-  }
-  NextId() {
-    return this._idService.NextId();
-  }
-  Random0ToValue(value) {
-    return this._randomService.Random0ToValue(value);
-  }
-  Stdout() {
-    return this._basicRuntimeService.Stdout();
-  }
-  Stderr() {
-    return this._basicRuntimeService.Stderr();
-  }
-  Env() {
-    return this._basicRuntimeService.Env();
-  }
-  Args() {
-    return this._basicRuntimeService.Args();
-  }
-  // System(): SystemService {
-  //   return this._systemService;
-  // }
-  // FileSystem(): FileService {
-  //   return this._fileSystem;
-  // }
-};
-var WrapperRuntimeSysAbstraction = class extends WrapperBasicSysAbstraction {
-  constructor(base, params) {
-    var _a, _b;
-    super(base, params);
-    this._systemService = (_a = params.systemService) != null ? _a : base._systemService;
-    this._fileSystem = (_b = params.fileSystem) != null ? _b : base._fileSystem;
-  }
-  System() {
-    return this._systemService;
-  }
-  FileSystem() {
-    return this._fileSystem;
-  }
-};
-
-// src/web/web-basic-sys-abstraction.ts
-var WebSystemService = class {
-  constructor(ende) {
-    this._txtEnDe = ende;
-  }
-  Env() {
-    return envFactory();
-  }
-  Args() {
-    throw new Error("Args-Method not implemented.");
-  }
-  Stdout() {
-    return new ConsoleWriterStream();
-  }
-  Stderr() {
-    const decoder = this._txtEnDe;
-    return new WritableStream({
-      write(chunk) {
-        return new Promise((resolve) => {
-          const decoded = decoder.decode(chunk);
-          console.error(decoded.trimEnd());
-          resolve();
-        });
-      }
-    });
-  }
-};
-var baseSysAbstraction4 = new ResolveOnce();
-function WebBasicSysAbstraction(param) {
-  var _a;
-  const my = baseSysAbstraction4.once(() => {
-    return new BaseBasicSysAbstraction({
-      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || TxtEnDecoderSingleton()
-    });
-  });
-  return new WrapperBasicSysAbstraction(my, {
-    basicRuntimeService: new WebSystemService((_a = param == null ? void 0 : param.TxtEnDecoder) != null ? _a : my._txtEnDe),
-    ...param
-  });
-}
-
-export {
-  runtimeFn,
-  TimeMode,
-  RandomMode,
-  IDMode,
-  String2TimeMode,
-  Time,
-  TimeUnits,
-  CFEnvActions,
-  registerEnvAction,
-  envFactory,
-  EnvImpl,
-  WebBasicSysAbstraction,
-  CFRuntimeService,
-  CFBasicSysAbstraction,
-  DenoBasicSysAbstraction,
-  NodeBasicSysAbstraction,
-  SysTime,
-  ConstTime,
-  StepTime,
-  TimeFactory,
-  RandomService,
-  IdService,
-  BaseBasicSysAbstraction,
-  BaseSysAbstraction,
-  BasicSysAbstractionFactory,
-  WrapperBasicSysAbstraction,
-  WrapperRuntimeSysAbstraction
-};
-//# sourceMappingURL=chunk-FURW5CDL.js.map