@adviser/cement 0.3.3 → 0.3.5

package/src/runtime.ts

@@ -6,14 +6,13 @@ export interface Runtime {
   isCFWorker: boolean;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function isSet(value: string, ref: any = globalThis): boolean {
+function isSet(value: string, ref: Record<string, unknown> = globalThis): boolean {
   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 isSet(tail.join("."), ref[head] as Record<string, unknown>);
   }
   return false;
 }
@@ -24,6 +23,7 @@ export function runtimeFn(): Runtime {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const gt: any = 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")) {

package/src/sys-env.ts

@@ -1,8 +1,12 @@
-import { DenoEnvActions } from "./deno/deno-sys-abstraction.js";
-import { NodeEnvActions } from "./node/node-sys-abstraction.js";
-import { BrowserEnvActions } from "./web/web-sys-abstraction.js";
-import { CFEnvActions } from "./cf/cf-sys-abstraction.js";
+import { DenoEnvActions } from "./deno/deno-env-actions.js";
+import { NodeEnvActions } from "./node/node-env-actions.js";
+import { BrowserEnvActions } from "./web/web-env-actions.js";
+import { CFEnvActions } from "./cf/cf-env-actions.js";
 import { KeyedResolvOnce } from "./resolve-once.js";
+import { Result } from "./result.js";
+import { getParamsResult, KeysParam } from "./utils/get-params-result.js";
+
+export type EnvTuple = ([string, string] | [string, string][] | Record<string, string> | Iterator<[string, string]>)[];
 
 export interface EnvMap {
   get(key: string): string | undefined;
@@ -28,6 +32,9 @@ export interface OnSetItem {
 
 export interface Env extends EnvMap {
   onSet(fn: OnSetFn, ...filter: string[]): void;
+
+  gets(...kparams: KeysParam): Result<Record<string, string>>;
+  sets(...keys: EnvTuple): void;
 }
 
 export type EnvFactoryFn = (opts: Partial<EnvFactoryOpts>) => EnvActions;
@@ -66,12 +73,65 @@ export function envFactory(opts: Partial<EnvFactoryOpts> = {}): Env {
   });
 }
 
+function isIterable(obj: unknown): obj is Iterable<[string, string]> {
+  // checks for null and undefined
+  if (obj == null) {
+    return false;
+  }
+  return typeof (obj as Record<symbol, unknown>)[Symbol.iterator] === "function";
+}
+
 export class EnvImpl implements Env {
   readonly _map: EnvMap;
   constructor(map: EnvMap, opts: Partial<EnvFactoryOpts> = {}) {
     this._map = map;
     this._updatePresets(opts.presetEnv);
   }
+  gets(...kparams: KeysParam): Result<Record<string, string>> {
+    return getParamsResult(kparams, {
+      getParam: (k) => this.get(k),
+    });
+  }
+  sets(...keys: EnvTuple): void {
+    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)) {
+            // [string, string]
+            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 as Record<string, string>;
+          for (const k in rKey) {
+            const v = rKey[k];
+            if (typeof k === "string" && typeof v === "string") {
+              this.set(k, v);
+            }
+          }
+        }
+      }
+    });
+  }
   _updatePresets(presetEnv?: Map<string, string>): void {
     if (!presetEnv) {
       return;

package/src/test/log-write-stream.ts

@@ -61,7 +61,7 @@ export class LogCollector implements WritableStream<Uint8Array> {
 
   getWriter(): WritableStreamDefaultWriter<Uint8Array> {
     if (!this._writer) {
-      const dests: WritableStreamDefaultWriter[] = [new LogWriteStream(this._bufferArr)];
+      const dests: WritableStreamDefaultWriter<Uint8Array>[] = [new LogWriteStream(this._bufferArr)];
       if (this._pass) {
         dests.push(this._pass);
       }
@@ -87,6 +87,7 @@ export class LogCollector implements WritableStream<Uint8Array> {
     if (!notJsonLine) {
       const splitStr = jsonNlStr.split("\n");
       const filterStr = splitStr.filter((a) => a.length);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       const mapStr = filterStr.map((a) => JSON.parse(a));
       return mapStr;
     }

package/src/tracer.ts

@@ -38,14 +38,12 @@ export class Metric<T> {
   add<R extends number | ArrayLike<T>>(value: R): void {
     if (typeof value === "number") {
       if (this.value === undefined) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.value = 0 as any;
+        this.value = 0 as T;
       }
-      (this.value as number) = ((this.value as number) + value) as number;
+      this.value = ((this.value as number) + value) as T;
     } else if (Array.isArray(value)) {
       if (!Array.isArray(this.value)) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.value = [] as any;
+        this.value = [] as T;
       }
       (this.value as T[]).push(...value);
     } else {
@@ -145,7 +143,7 @@ export class TraceNode {
     const spanRefs = this.metrics.toJSON.call({ map: this.metrics.spanRefs });
     const metricsRefs = Object.keys(spanRefs).length > 0 ? { metricRefs: spanRefs } : {};
     return {
-      ctx: cleanCtx as CleanCtx,
+      ctx: cleanCtx,
       invokations: this.invokations,
       ...metricsRefs,
     };

package/src/uri.ts

@@ -1,4 +1,5 @@
 import { exception2Result, Result } from "./result.js";
+import { getParamsResult, KeysParam, param } from "./utils/get-params-result.js";
 import { relativePath } from "./utils/relative-path.js";
 import { StripCommand, stripper } from "./utils/stripper.js";
 
@@ -6,30 +7,14 @@ type NullOrUndef = null | undefined;
 
 type OneKey<K extends string, V = string> = Record<K, V>;
 
-export type MsgFn = (...keys: string[]) => string;
+/** @deprecated use param from get-params-result */
+export const key = param;
+
 /*
   if KeyParam is a Object
      if the right side is a string, it is the default value
      if the right side is a !string | REQUIRED, it is required
 */
-class _REQUIRED {
-  readonly val = "REQUIRED";
-}
-class _OPTIONAL {
-  readonly val = "OPTIONAL";
-}
-
-interface _key {
-  readonly REQUIRED: _REQUIRED;
-  readonly OPTIONAL: _OPTIONAL;
-}
-
-export const key: _key = {
-  REQUIRED: new _REQUIRED(),
-  OPTIONAL: new _OPTIONAL(),
-};
-
-export type KeysParam = (string | MsgFn | Record<string, _REQUIRED | _OPTIONAL | unknown>)[];
 
 // type ReturnType<T extends (...args: KeysParam) => unknown> = T extends (...args: KeysParam) => infer R ? R : unknown;
 
@@ -272,56 +257,6 @@ function getParamResult(
   return Result.Ok(val);
 }
 
-function getParamsResult(
-  keys: KeysParam,
-  getParam: { getParam: (key: string) => string | undefined },
-): Result<Record<string, string>> {
-  const keyDef = keys.flat().reduce(
-    (acc, i) => {
-      if (typeof i === "string") {
-        acc.push({ key: i, def: undefined, isOptional: false });
-      } else if (typeof i === "object") {
-        acc.push(
-          ...Object.keys(i).map((k) => ({
-            key: k,
-            def: typeof i[k] === "string" ? i[k] : undefined,
-            isOptional: i[k] instanceof _OPTIONAL,
-          })),
-        );
-      }
-      return acc;
-    },
-    [] as { key: string; def?: string; isOptional: boolean }[],
-  );
-  //.filter((k) => typeof k === "string");
-  const msgFn =
-    keys.find((k) => typeof k === "function") ||
-    ((...keys: string[]): string => {
-      const msg = keys.join(",");
-      return `missing parameters: ${msg}`;
-    });
-  const errors: string[] = [];
-  const result: Record<string, string> = {};
-  for (const kd of keyDef) {
-    const val = getParam.getParam(kd.key);
-    if (val === undefined) {
-      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);
-}
-
 export class BuildURI implements URIInterface<BuildURI> {
   _url: MutableURL; // pathname needs this
   private constructor(url: MutableURL) {

package/src/utils/console-write-stream.ts

@@ -23,7 +23,7 @@ export class ConsoleWriterStreamDefaultWriter implements WritableStreamDefaultWr
     this.ready = Promise.resolve(undefined);
     this.closed = Promise.resolve(undefined);
   }
-  async write(chunk?: Uint8Array | undefined): Promise<void> {
+  write(chunk?: Uint8Array): Promise<void> {
     let strObj: string | { level: string } = this.decoder.decode(chunk).trimEnd();
     let output = "log";
     try {
@@ -46,6 +46,7 @@ export class ConsoleWriterStreamDefaultWriter implements WritableStreamDefaultWr
         // eslint-disable-next-line no-console
         console.log(strObj);
     }
+    return Promise.resolve();
   }
 }
 
@@ -56,8 +57,8 @@ export class ConsoleWriterStream implements WritableStream<Uint8Array> {
   abort(reason?: any): Promise<void> {
     throw new Error("Method not implemented.");
   }
-  async close(): Promise<void> {
-    return;
+  close(): Promise<void> {
+    return Promise.resolve();
   }
   getWriter(): WritableStreamDefaultWriter<Uint8Array> {
     if (this.locked) {

package/src/utils/fanout-write-stream.ts

@@ -24,7 +24,7 @@ export class FanoutWriteStream implements WritableStreamDefaultWriter<Uint8Array
     this._writers.map((w) => w.releaseLock());
   }
 
-  write(chunk?: Uint8Array | undefined): Promise<void> {
+  write(chunk?: Uint8Array): Promise<void> {
     return Promise.all(this._writers.map((w) => w.write(chunk))).then(() => {
       /* do nothing */
     });

package/src/utils/get-params-result.ts

@@ -0,0 +1,71 @@
+import { Result } from "../result.js";
+
+class _REQUIRED {
+  readonly val = "REQUIRED";
+}
+class _OPTIONAL {
+  readonly val = "OPTIONAL";
+}
+
+export interface Param {
+  readonly REQUIRED: _REQUIRED;
+  readonly OPTIONAL: _OPTIONAL;
+}
+
+export const param: Param = {
+  REQUIRED: new _REQUIRED(),
+  OPTIONAL: new _OPTIONAL(),
+};
+
+export type MsgFn = (...keys: string[]) => string;
+export type KeysParam = (string | MsgFn | Record<string, _REQUIRED | _OPTIONAL | number | string | boolean | undefined | null>)[];
+
+export function getParamsResult(
+  keys: KeysParam,
+  getParam: { getParam: (key: string) => string | undefined },
+): Result<Record<string, string>> {
+  const keyDef = keys.flat().reduce(
+    (acc, i) => {
+      if (typeof i === "string") {
+        acc.push({ key: i, def: undefined, isOptional: false });
+      } else if (typeof i === "object") {
+        acc.push(
+          ...Object.keys(i).map((k) => ({
+            key: k,
+            def: typeof i[k] === "string" ? i[k] : undefined,
+            isOptional: i[k] === param.OPTIONAL,
+          })),
+        );
+      }
+      return acc;
+    },
+    [] as { key: string; def?: string; isOptional: boolean }[],
+  );
+  //.filter((k) => typeof k === "string");
+  const msgFn =
+    keys.find((k) => typeof k === "function") ||
+    ((...keys: string[]): string => {
+      const msg = keys.join(",");
+      return `missing parameters: ${msg}`;
+    });
+  const errors: string[] = [];
+  const result: Record<string, string> = {};
+  for (const kd of keyDef) {
+    const val = getParam.getParam(kd.key);
+    if (val === undefined) {
+      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);
+}

package/src/utils/index.ts

@@ -4,3 +4,4 @@ export * from "./stream2string.js";
 export * from "./string2stream.js";
 export * from "./console-write-stream.js";
 export * from "./fanout-write-stream.js";
+export * from "./get-params-result.js";

package/src/utils/rebuffer.ts

@@ -33,29 +33,35 @@ interface pumpState {
 }
 
 function pump(ps: pumpState, controller: ReadableStreamDefaultController<Uint8Array>, next: () => void): void {
-  ps.reader.read().then(({ done, value }) => {
-    if (done) {
-      if (ps.tmpLen > 0) {
-        controller.enqueue(reChunk(ps.tmp, ps.tmpLen).chunk);
+  ps.reader
+    .read()
+    .then(({ done, value }) => {
+      if (done) {
+        if (ps.tmpLen > 0) {
+          controller.enqueue(reChunk(ps.tmp, ps.tmpLen).chunk);
+        }
+        controller.close();
+        next();
+        return;
       }
-      controller.close();
-      next();
-      return;
-    }
-    if (ps.tmpLen + value.length > ps.chunkSize) {
-      ps.tmp.push(value);
-      const res = reChunk(ps.tmp, ps.chunkSize);
-      controller.enqueue(res.chunk);
-      ps.tmp = [res.rest];
-      ps.tmpLen = res.rest.length;
+      if (ps.tmpLen + value.length > ps.chunkSize) {
+        ps.tmp.push(value);
+        const res = reChunk(ps.tmp, ps.chunkSize);
+        controller.enqueue(res.chunk);
+        ps.tmp = [res.rest];
+        ps.tmpLen = res.rest.length;
+        next();
+        return;
+      } else if (value.length) {
+        ps.tmp.push(value);
+        ps.tmpLen += value.length;
+      }
+      pump(ps, controller, next);
+    })
+    .catch((err) => {
+      controller.error(err);
       next();
-      return;
-    } else if (value.length) {
-      ps.tmp.push(value);
-      ps.tmpLen += value.length;
-    }
-    pump(ps, controller, next);
-  });
+    });
 }
 
 export function rebuffer(a: ReadableStream<Uint8Array>, chunkSize: number): ReadableStream<Uint8Array> {

package/src/utils/relative-path.ts

@@ -38,7 +38,7 @@ export class Path {
     if (this.parts.includes(PartType.Root) && part === PartType.Root) {
       throw new Error("Cannot add absolute part to absolute path");
     }
-    const last = this.parts[this.parts.length - 1] as number;
+    const last = this.parts[this.parts.length - 1] as PartType;
     if (last & PartType.Slash && part === PartType.Slash) {
       return;
     }

package/src/utils/stream2string.ts

@@ -19,7 +19,7 @@ export async function stream2string(stream?: ReadableStream<Uint8Array> | null,
       rSize += read.value.length;
       res += block;
     } catch (err) {
-      return Promise.reject(err);
+      return Promise.reject(err as Error);
     }
   }
   return Promise.resolve(res);
@@ -40,7 +40,7 @@ export async function stream2uint8array(stream?: ReadableStream<Uint8Array> | nu
       }
       res = new Uint8Array([...res, ...value]);
     } catch (err) {
-      return Promise.reject(err);
+      return Promise.reject(err as Error);
     }
   }
   return Promise.resolve(res);

package/src/utils/stripper.ts

@@ -1,6 +1,6 @@
 export type StripCommand = string | RegExp;
 
-export function stripper<T extends unknown | ArrayLike<unknown>>(
+export function stripper<T extends ArrayLike<S> | S, S>(
   strip: StripCommand | StripCommand[],
   obj: T,
 ): T extends ArrayLike<unknown> ? Record<string, unknown>[] : Record<string, unknown> {
@@ -49,7 +49,7 @@ function localStripper<T>(path: string | undefined, restrips: RegExp[], obj: T):
       }
       if (typeof ret[key] === "object") {
         if (Array.isArray(ret[key])) {
-          ret[key] = ret[key].reduce((acc, v, i) => {
+          ret[key] = ret[key].reduce((acc: unknown[], v, i) => {
             const toDelete = matcher(key, `${nextPath}[${i}]`);
             if (!toDelete) {
               acc.push(localStripper(`${nextPath}[${i}]`, restrips, v));

package/src/version.ts

@@ -1,3 +1,3 @@
-export const VERSION = Object.keys({
+export const VERSION: string = Object.keys({
   __packageVersion__: "xxxx",
-})[0] as string;
+})[0];

package/src/web/web-env-actions.ts

@@ -0,0 +1,41 @@
+import { ResolveOnce } from "../resolve-once.js";
+import { EnvActions, EnvFactoryOpts, Env } from "../sys-env.js";
+
+const once = new ResolveOnce<BrowserEnvActions>();
+export class BrowserEnvActions implements EnvActions {
+  readonly env: Map<string, string> = new Map<string, string>();
+  readonly opts: Partial<EnvFactoryOpts>;
+
+  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
+    return once.once(() => new BrowserEnvActions(opts));
+  }
+
+  private constructor(opts: Partial<EnvFactoryOpts>) {
+    this.opts = opts;
+  }
+
+  get(key: string): string | undefined {
+    return this.env.get(key);
+  }
+  set(key: string, value?: string): void {
+    if (value) {
+      this.env.set(key, value);
+    }
+  }
+  delete(key: string): void {
+    this.env.delete(key);
+  }
+  keys(): string[] {
+    return Array.from(this.env.keys());
+  }
+  active(): boolean {
+    return true; // that should work on every runtime
+  }
+
+  register(env: Env): Env {
+    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
+    const browser = globalThis as unknown as Record<symbol, Env>;
+    browser[sym] = env;
+    return env;
+  }
+}

package/src/web/web-sys-abstraction.ts

@@ -1,49 +1,9 @@
 import { BaseSysAbstraction, WrapperSysAbstraction, WrapperSysAbstractionParams } from "../base-sys-abstraction.js";
 import { FileService, NamedWritableStream } from "../file-service.js";
-import { ResolveOnce } from "../resolve-once.js";
 import { SysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
-import { Env, EnvActions, envFactory, EnvFactoryOpts } from "../sys-env.js";
+import { Env, envFactory } from "../sys-env.js";
 import { Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
 
-const once = new ResolveOnce<BrowserEnvActions>();
-export class BrowserEnvActions implements EnvActions {
-  readonly env: Map<string, string> = new Map<string, string>();
-  readonly opts: Partial<EnvFactoryOpts>;
-
-  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
-    return once.once(() => new BrowserEnvActions(opts));
-  }
-
-  private constructor(opts: Partial<EnvFactoryOpts>) {
-    this.opts = opts;
-  }
-
-  get(key: string): string | undefined {
-    return this.env.get(key);
-  }
-  set(key: string, value?: string): void {
-    if (value) {
-      this.env.set(key, value);
-    }
-  }
-  delete(key: string): void {
-    this.env.delete(key);
-  }
-  keys(): string[] {
-    return Array.from(this.env.keys());
-  }
-  active(): boolean {
-    return true; // that should work on every runtime
-  }
-
-  register(env: Env): Env {
-    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
-    const browser = globalThis as unknown as Record<symbol, Env>;
-    browser[sym] = env;
-    return env;
-  }
-}
-
 export class WebFileService implements FileService {
   get baseDir(): string {
     throw new Error("basedir-Method not implemented.");
@@ -69,7 +29,7 @@ export class WebFileService implements FileService {
     throw new Error("join-Method not implemented.");
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  relative(from: string, to?: string | undefined): string {
+  relative(from: string, to?: string): string {
     throw new Error("relative-Method not implemented.");
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars

package/{sys-abstraction-GNnBj2sz.d.cts → sys-abstraction-BRDT_TIU.d.cts}

@@ -1,3 +1,5 @@
+import { K as KeysParam, R as Result } from './get-params-result-Bhy5997x.cjs';
+
 interface NamedWritableStream {
     readonly name: string;
     readonly stream: WritableStream<Uint8Array>;
@@ -15,6 +17,7 @@ interface FileService {
     isAbsolute(fname: string): boolean;
 }
 
+type EnvTuple = ([string, string] | [string, string][] | Record<string, string> | Iterator<[string, string]>)[];
 interface EnvMap {
     get(key: string): string | undefined;
     set(key: string, value?: string): void;
@@ -36,6 +39,8 @@ interface OnSetItem {
 }
 interface Env extends EnvMap {
     onSet(fn: OnSetFn, ...filter: string[]): void;
+    gets(...kparams: KeysParam): Result<Record<string, string>>;
+    sets(...keys: EnvTuple): void;
 }
 type EnvFactoryFn = (opts: Partial<EnvFactoryOpts>) => EnvActions;
 declare function registerEnvAction(fn: EnvFactoryFn): () => void;
@@ -43,6 +48,8 @@ declare function envFactory(opts?: Partial<EnvFactoryOpts>): Env;
 declare class EnvImpl implements Env {
     readonly _map: EnvMap;
     constructor(map: EnvMap, opts?: Partial<EnvFactoryOpts>);
+    gets(...kparams: KeysParam): Result<Record<string, string>>;
+    sets(...keys: EnvTuple): void;
     _updatePresets(presetEnv?: Map<string, string>): void;
     _applyOnSet(onSet: OnSetItem[], key?: string, value?: string): void;
     readonly _onSet: OnSetItem[];
@@ -99,4 +106,4 @@ interface SysAbstraction {
     FileSystem(): FileService;
 }
 
-export { type Duration as D, type EnvActions as E, type FileService as F, IDMode as I, type NamedWritableStream as N, type OnSetItem as O, RandomMode as R, type SystemService as S, Time as T, type VoidFunc as V, EnvImpl as a, type EnvFactoryOpts as b, type Env as c, type SysAbstraction as d, TimeMode as e, String2TimeMode as f, type EnvMap as g, type EnvFactoryFn as h, envFactory as i, TimeUnits as j, registerEnvAction as r };
+export { type Duration as D, type Env as E, type FileService as F, IDMode as I, type NamedWritableStream as N, type OnSetItem as O, RandomMode as R, type SystemService as S, Time as T, type VoidFunc as V, type SysAbstraction as a, TimeMode as b, String2TimeMode as c, type EnvTuple as d, type EnvMap as e, type EnvActions as f, type EnvFactoryOpts as g, type EnvFactoryFn as h, envFactory as i, EnvImpl as j, TimeUnits as k, registerEnvAction as r };

package/{sys-abstraction-GNnBj2sz.d.ts → sys-abstraction-Bd0EzwO6.d.ts}

@@ -1,3 +1,5 @@
+import { K as KeysParam, R as Result } from './get-params-result-Bhy5997x.js';
+
 interface NamedWritableStream {
     readonly name: string;
     readonly stream: WritableStream<Uint8Array>;
@@ -15,6 +17,7 @@ interface FileService {
     isAbsolute(fname: string): boolean;
 }
 
+type EnvTuple = ([string, string] | [string, string][] | Record<string, string> | Iterator<[string, string]>)[];
 interface EnvMap {
     get(key: string): string | undefined;
     set(key: string, value?: string): void;
@@ -36,6 +39,8 @@ interface OnSetItem {
 }
 interface Env extends EnvMap {
     onSet(fn: OnSetFn, ...filter: string[]): void;
+    gets(...kparams: KeysParam): Result<Record<string, string>>;
+    sets(...keys: EnvTuple): void;
 }
 type EnvFactoryFn = (opts: Partial<EnvFactoryOpts>) => EnvActions;
 declare function registerEnvAction(fn: EnvFactoryFn): () => void;
@@ -43,6 +48,8 @@ declare function envFactory(opts?: Partial<EnvFactoryOpts>): Env;
 declare class EnvImpl implements Env {
     readonly _map: EnvMap;
     constructor(map: EnvMap, opts?: Partial<EnvFactoryOpts>);
+    gets(...kparams: KeysParam): Result<Record<string, string>>;
+    sets(...keys: EnvTuple): void;
     _updatePresets(presetEnv?: Map<string, string>): void;
     _applyOnSet(onSet: OnSetItem[], key?: string, value?: string): void;
     readonly _onSet: OnSetItem[];
@@ -99,4 +106,4 @@ interface SysAbstraction {
     FileSystem(): FileService;
 }
 
-export { type Duration as D, type EnvActions as E, type FileService as F, IDMode as I, type NamedWritableStream as N, type OnSetItem as O, RandomMode as R, type SystemService as S, Time as T, type VoidFunc as V, EnvImpl as a, type EnvFactoryOpts as b, type Env as c, type SysAbstraction as d, TimeMode as e, String2TimeMode as f, type EnvMap as g, type EnvFactoryFn as h, envFactory as i, TimeUnits as j, registerEnvAction as r };
+export { type Duration as D, type Env as E, type FileService as F, IDMode as I, type NamedWritableStream as N, type OnSetItem as O, RandomMode as R, type SystemService as S, Time as T, type VoidFunc as V, type SysAbstraction as a, TimeMode as b, String2TimeMode as c, type EnvTuple as d, type EnvMap as e, type EnvActions as f, type EnvFactoryOpts as g, type EnvFactoryFn as h, envFactory as i, EnvImpl as j, TimeUnits as k, registerEnvAction as r };