@adviser/cement 0.4.34 → 0.4.36

package/src/lru-map-set.ts

@@ -1,18 +1,24 @@
 import { AppContext } from "./app-context.js";
 
-export interface LRUParam {
-  readonly maxEntries: number;
-  readonly maxAge: number; // not implemented
+interface MutableLRUParam<T, K> {
+  evict: (param: LRUParam<T, K>, newItem: T, map: LRUMap<K, T>) => boolean;
+  // is called if the params are changed
+  // default it removes the least recently accessed
+  refresh: (param: LRUParam<T, K>, map: Map<K, LRUItem<T>>) => void;
+  maxEntries: number;
+  maxAge: number; // not implemented
 }
 
+export type LRUParam<T = string, K = string> = Readonly<MutableLRUParam<T, K>>;
+
 export class LRUSet<T> {
   private readonly _lruMap: LRUMap<T, T>;
 
-  constructor(param: Partial<LRUParam> = {}) {
+  constructor(param: Partial<LRUParam<T, T>> = {}) {
     this._lruMap = new LRUMap<T, T>(param);
   }
 
-  setParam(param: Partial<LRUParam> = {}): void {
+  setParam(param: Partial<LRUParam<T, T>> = {}): void {
     this._lruMap.setParam(param);
   }
 
@@ -47,22 +53,40 @@ export class LRUSet<T> {
 
 export interface LRUCtx<T, K> {
   readonly update: boolean;
-  readonly ref: LRUMap<T, K>;
+  readonly ref: LRUMap<K, T>;
   readonly stats: LRUMap<T, K>["stats"];
-  readonly item: LRUItem<K>;
+  readonly item: LRUItem<T>;
 }
 
-export interface LRUItem<K> {
-  readonly value: K;
+export interface LRUItem<V> {
+  readonly value: V;
   ctx?: AppContext;
 }
 
-export type LRUMapFn<K, T> = (key: K, value: T, meta: LRUCtx<K, T>) => void;
+export type LRUMapFn<K, T> = (value: T, key: K, meta: LRUCtx<K, T>) => void;
 export type UnregFn = () => void;
 
-export class LRUMap<T, K> {
-  private _map: Map<T, LRUItem<K>> = new Map<T, LRUItem<K>>();
-  private param: LRUParam;
+function defaultRefresh<V, K>(param: LRUParam<V, K>, map: Map<K, LRUItem<V>>): void {
+  if (param.maxEntries > 0 && map.size > param.maxEntries) {
+    const toDelete: K[] = [];
+    let cacheSize = map.size;
+    for (const key of map.keys()) {
+      if (cacheSize > param.maxEntries) {
+        toDelete.push(key);
+        cacheSize--;
+      } else {
+        break;
+      }
+    }
+    for (const key of toDelete) {
+      map.delete(key);
+    }
+  }
+}
+
+export class LRUMap<K, V> {
+  private _map: Map<K, LRUItem<V>> = new Map<K, LRUItem<V>>();
+  private param: MutableLRUParam<V, K>;
 
   readonly stats = {
     gets: 0,
@@ -70,23 +94,25 @@ export class LRUMap<T, K> {
     deletes: 0,
   };
 
-  constructor(c: Partial<LRUParam> = {}) {
+  constructor(c: Partial<LRUParam<V, K>> = {}) {
     this.param = {
       maxEntries: c.maxEntries || 100,
       maxAge: c.maxAge || 0,
+      evict: c.evict || ((param, _newItem, map): boolean => param.maxEntries > 0 && map.size >= param.maxEntries),
+      refresh: c.refresh || ((param: LRUParam<V, K>, map: Map<K, LRUItem<V>>): void => defaultRefresh(param, map)),
     };
   }
 
-  private _onSetFns: Map<string, LRUMapFn<T, K>> = new Map<string, LRUMapFn<T, K>>();
-  onSet(fn: LRUMapFn<T, K>): UnregFn {
+  private _onSetFns: Map<string, LRUMapFn<V, K>> = new Map<string, LRUMapFn<V, K>>();
+  onSet(fn: LRUMapFn<V, K>): UnregFn {
     const id = Math.random().toString(36);
     this._onSetFns.set(id, fn);
     return () => {
       this._onSetFns.delete(id);
     };
   }
-  private _onDeleteFns: Map<string, LRUMapFn<T, K>> = new Map<string, LRUMapFn<T, K>>();
-  onDelete(fn: LRUMapFn<T, K>): UnregFn {
+  private _onDeleteFns: Map<string, LRUMapFn<V, K>> = new Map<string, LRUMapFn<V, K>>();
+  onDelete(fn: LRUMapFn<V, K>): UnregFn {
     const id = Math.random().toString(36);
     this._onDeleteFns.set(id, fn);
     return () => {
@@ -94,39 +120,35 @@ export class LRUMap<T, K> {
     };
   }
 
-  private touch(key: T): LRUItem<K> {
+  private touch(key: K): LRUItem<V> {
     if (!this._map.has(key)) {
       throw new Error(`key not found in cache: ${key as unknown as string}`);
     }
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-    const value = this._map.get(key) as LRUItem<K>;
+    const value = this._map.get(key) as LRUItem<V>;
     this._map.delete(key);
     this._map.set(key, value);
     return value;
   }
 
-  setParam(param: Partial<LRUParam> = {}): void {
+  setParam(param: Partial<LRUParam<V, K>> = {}): void {
+    if (param.evict) {
+      this.param.evict = param.evict;
+    }
+    if (param.refresh) {
+      this.param.refresh = param.refresh;
+    }
     if (typeof param.maxEntries === "number") {
-      (this.param as { maxEntries: number }).maxEntries = param.maxEntries;
-      if (param.maxEntries > 0 && this._map.size > param.maxEntries) {
-        const toDelete: T[] = [];
-        let cacheSize = this._map.size;
-        for (const key of this._map.keys()) {
-          if (cacheSize > param.maxEntries) {
-            toDelete.push(key);
-            cacheSize--;
-          } else {
-            break;
-          }
-        }
-        for (const key of toDelete) {
-          this._map.delete(key);
-        }
-      }
+      this.param.maxEntries = param.maxEntries;
+    }
+    if (typeof param.maxAge === "number") {
+      this.param.maxAge = param.maxAge;
     }
+
+    this.param.refresh(this.param, this._map);
   }
 
-  has(key: T): boolean {
+  has(key: K): boolean {
     return this._map.has(key);
   }
 
@@ -134,22 +156,22 @@ export class LRUMap<T, K> {
     return this._map.size;
   }
 
-  async getSet(key: T, createFN: (key: T) => Promise<K>): Promise<K | undefined> {
+  async getSet(key: K, createFN: (key: K) => Promise<V>): Promise<V | undefined> {
     const val = this.get(key);
     if (val) {
       return val;
     } else {
       const val = await createFN(key);
-      this.set(key, val as K);
+      this.set(key, val as V);
       return val;
     }
   }
 
-  get(key: T): K | undefined {
+  get(key: K): V | undefined {
     return this.getItem(key)?.value;
   }
 
-  getItem(key: T): LRUItem<K> | undefined {
+  getItem(key: K): LRUItem<V> | undefined {
     if (this._map.has(key)) {
       this.stats.gets++;
       return this.touch(key);
@@ -157,14 +179,14 @@ export class LRUMap<T, K> {
     return undefined;
   }
 
-  private buildItem(item: LRUItem<K> | undefined, value: K): LRUItem<K> {
+  private buildItem(item: LRUItem<V> | undefined, value: V): LRUItem<V> {
     return {
       ...item,
       value,
     };
   }
 
-  set(key: T, value: K): void {
+  set(key: K, value: V): void {
     const update = this._map.has(key);
     let item = this._map.get(key);
     if (update) {
@@ -175,13 +197,13 @@ export class LRUMap<T, K> {
       this._map.delete(key);
     }
     item = this.buildItem(item, value);
-    if (this.param.maxEntries > 0 && this._map.size >= this.param.maxEntries) {
+    if (this.param.evict(this.param, value, this)) {
       // delete the least recently accessed
       // const key = Array.from(this.cache.keys())[0];
       // this.cache.delete(key) or
-      const v = this._map.keys().next();
-      if (!v.done) {
-        this._map.delete(v.value as T);
+      const k = this._map.keys().next();
+      if (!k.done) {
+        this._map.delete(k.value as K);
       }
     }
     this._map.set(key, item);
@@ -189,7 +211,7 @@ export class LRUMap<T, K> {
     this._onSetFns.forEach((fn) => fn(key, item?.value, this.buildItemCtx(item, update)));
   }
 
-  private buildItemCtx(item: LRUItem<K>, update: boolean): LRUCtx<T, K> {
+  private buildItemCtx(item: LRUItem<V>, update: boolean): LRUCtx<V, K> {
     return {
       update,
       ref: this,
@@ -198,10 +220,10 @@ export class LRUMap<T, K> {
     };
   }
 
-  delete(key: T): void {
+  delete(key: K): void {
     if (this._map.has(key)) {
       // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-      const item = this._map.get(key) as LRUItem<K>;
+      const item = this._map.get(key) as LRUItem<V>;
       this._onDeleteFns.forEach((fn) => fn(key, item?.value, this.buildItemCtx(item, true)));
       this._map.delete(key);
       this.stats.deletes++;
@@ -217,13 +239,13 @@ export class LRUMap<T, K> {
     this._map.clear();
   }
 
-  forEach(fn: (value: K, key: T, ctx: LRUCtx<T, K>) => void): void {
+  forEach(fn: (value: V, key: K, ctx: LRUCtx<V, K>) => void): void {
     this._map.forEach((v, k) => {
       fn(v.value, k, this.buildItemCtx(v, false));
     });
   }
 
-  *entries(): IterableIterator<[T, K, LRUCtx<T, K>]> {
+  *entries(): IterableIterator<[K, V, LRUCtx<V, K>]> {
     for (const [key, value] of this._map.entries()) {
       yield [key, value.value, this.buildItemCtx(value, true)];
     }

package/src/mutable-url.ts

@@ -62,7 +62,7 @@ export class ReadonlyURL extends URL {
     // this.hash = this._sysURL.hash;
   }
 
-  set origin(h: string) {
+  override set origin(h: string) {
     throw new Error("origin is readonly");
   }
 
@@ -70,7 +70,7 @@ export class ReadonlyURL extends URL {
     return this.toString();
   }
 
-  set href(h: string) {
+  override set href(h: string) {
     throw new Error("href is readonly");
   }
 
@@ -78,7 +78,7 @@ export class ReadonlyURL extends URL {
     return this._sysURL.password;
   }
 
-  set password(h: string) {
+  override set password(h: string) {
     throw new Error("password is readonly");
   }
 
@@ -86,11 +86,11 @@ export class ReadonlyURL extends URL {
     return this._sysURL.username;
   }
 
-  set username(h: string) {
+  override set username(h: string) {
     throw new Error("username is readonly");
   }
 
-  toJSON(): string {
+  override toJSON(): string {
     return this.toString();
   }
 
@@ -108,12 +108,12 @@ export class ReadonlyURL extends URL {
     return this._sysURL.hash;
   }
 
-  set hash(h: string) {
+  override set hash(h: string) {
     throw new Error("hash is readonly");
   }
 
   // Host getter and setter
-  get host(): string {
+  override get host(): string {
     if (!this._hasHostpart) {
       throw new Error(
         `you can use hostname only if protocol is ${this.toString()} ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`,
@@ -122,19 +122,19 @@ export class ReadonlyURL extends URL {
     return this._sysURL.host;
   }
 
-  set host(h: string) {
+  override set host(h: string) {
     throw new Error("host is readonly");
   }
 
   // Hostname getter and setter
-  get hostname(): string {
+  override get hostname(): string {
     if (!this._hasHostpart) {
       throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
     }
     return this._sysURL.hostname;
   }
 
-  set hostname(h: string) {
+  override set hostname(h: string) {
     throw new Error("hostname is readonly");
   }
 
@@ -143,7 +143,7 @@ export class ReadonlyURL extends URL {
     return this._pathname;
   }
 
-  set pathname(h: string) {
+  override set pathname(h: string) {
     throw new Error("pathname is readonly");
   }
 
@@ -155,7 +155,7 @@ export class ReadonlyURL extends URL {
     return this._sysURL.port;
   }
 
-  set port(h: string) {
+  override set port(h: string) {
     throw new Error("port is readonly");
   }
 
@@ -164,12 +164,12 @@ export class ReadonlyURL extends URL {
     return this._protocol;
   }
 
-  set protocol(h: string) {
+  override set protocol(h: string) {
     throw new Error("protocol is readonly");
   }
 
   // Search getter and setter
-  get search(): string {
+  override get search(): string {
     let search = "";
     if (this._sysURL.searchParams.size) {
       for (const [key, value] of Array.from(URLSearchParamsEntries(this._sysURL.searchParams)).sort((a, b) =>
@@ -181,7 +181,7 @@ export class ReadonlyURL extends URL {
     return search;
   }
 
-  set search(h: string) {
+  override set search(h: string) {
     throw new Error("search is readonly");
   }
 
@@ -190,7 +190,7 @@ export class ReadonlyURL extends URL {
     return this._sysURL.searchParams;
   }
 
-  set searchParams(h: URLSearchParams) {
+  override set searchParams(h: URLSearchParams) {
     throw new Error("searchParams is readonly");
   }
 
@@ -216,11 +216,11 @@ export class ReadonlyURL extends URL {
 export class WritableURL extends ReadonlyURL {
   // override readonly hash: string;
 
-  static readonly fromThrow = (urlStr: string): WritableURL => {
+  static override readonly fromThrow = (urlStr: string): WritableURL => {
     return new WritableURL(urlStr);
   };
 
-  static from(urlStr: string): Result<WritableURL> {
+  static override from(urlStr: string): Result<WritableURL> {
     if (urlRegex.test(urlStr)) {
       return exception2Result(() => new WritableURL(urlStr));
     }
@@ -235,24 +235,24 @@ export class WritableURL extends ReadonlyURL {
     return this.toString();
   }
 
-  [customInspectSymbol](): string {
+  override [customInspectSymbol](): string {
     // make node inspect to show the URL and not crash if URI is not http/https/file
     return this.toString();
   }
 
-  clone(): WritableURL {
+  override clone(): WritableURL {
     return new WritableURL(this.toString());
   }
 
-  set origin(_h: string) {
+  override set origin(_h: string) {
     throw new Error("don't use origin");
   }
 
-  get href(): string {
+  override get href(): string {
     return super.href;
   }
 
-  set href(h: string) {
+  override set href(h: string) {
     throw new Error("don't use href");
   }
 
@@ -260,7 +260,7 @@ export class WritableURL extends ReadonlyURL {
     return super.password;
   }
 
-  set password(h: string) {
+  override set password(h: string) {
     this._sysURL.password = h;
   }
 
@@ -268,7 +268,7 @@ export class WritableURL extends ReadonlyURL {
     return super.username;
   }
 
-  set username(h: string) {
+  override set username(h: string) {
     this._sysURL.username = h;
   }
 

package/src/resolve-once.ts

@@ -1,18 +1,21 @@
 import { Future } from "./future.js";
-import { NonPromise, UnPromisify } from "./is-promise.js";
+import { UnPromisify } from "./is-promise.js";
 import { isPromise } from "./is-promise.js";
 import { LRUMap, LRUParam, UnregFn } from "./lru-map-set.js";
 import { Result } from "./result.js";
 import { Option } from "./option.js";
 
-interface ResolveSeqItem<C, R extends NonPromise<X>, X = string | number | boolean | symbol | object> {
-  readonly future: Future<R>;
-  readonly fn: (c?: C) => R | Promise<R>;
+// interface ResolveSeqItem<C, R extends NonPromise<X>, X = string | number | boolean | symbol | object> {
+interface ResolveSeqItem<C, T, R> {
+  readonly future: Future<T>;
+  readonly fn: (c?: C) => R;
   readonly id?: number;
 }
 
-export class ResolveSeq<T extends NonPromise<X>, C = void, X = string | number | boolean | symbol | object> {
+export class ResolveSeq<T, C extends NonNullable<object> = object> {
   readonly ctx?: C;
+  readonly _seqFutures: ResolveSeqItem<C, T, unknown>[] = [];
+
   constructor(ctx?: C) {
     this.ctx = ctx;
   }
@@ -29,14 +32,14 @@ export class ResolveSeq<T extends NonPromise<X>, C = void, X = string | number |
     }
     return Promise.resolve();
   }
-  async _step(item?: ResolveSeqItem<C, T, X>): Promise<void> {
+  async _step(item?: ResolveSeqItem<C, T, Promise<T> | T>): Promise<void> {
     if (!item) {
       // done
       this._flushWaiting.forEach((f) => f.resolve());
       this._flushWaiting?.splice(0, this._flushWaiting.length);
       return Promise.resolve();
     }
-    let value;
+    let value: T;
     try {
       const promiseOrValue = item.fn(this.ctx);
       if (isPromise(promiseOrValue)) {
@@ -44,20 +47,19 @@ export class ResolveSeq<T extends NonPromise<X>, C = void, X = string | number |
       } else {
         value = promiseOrValue;
       }
-      item.future.resolve(value as T);
+      item.future.resolve(value);
     } catch (e) {
       item.future.reject(e as Error);
     } finally {
       this._seqFutures.shift();
     }
-    return this._step(this._seqFutures[0]);
+    return this._step(this._seqFutures[0] as ResolveSeqItem<C, T, Promise<T> | T>);
   }
-  readonly _seqFutures: ResolveSeqItem<C, T, X>[] = [];
   add<R extends Promise<T> | T>(fn: (c?: C) => R, id?: number): R {
     const future = new Future<T>();
     this._seqFutures.push({ future, fn, id });
     if (this._seqFutures.length === 1) {
-      void this._step(this._seqFutures[0]); // exit into eventloop
+      void this._step(this._seqFutures[0] as ResolveSeqItem<C, T, Promise<T> | T>); // exit into eventloop
     }
     return future.asPromise() as R; // as Promise<UnPromisify<R>>;
   }
@@ -392,18 +394,23 @@ export class ResolveOnce<T, CTX = void> implements ResolveOnceIf<T, CTX> {
   }
 }
 
-export interface KeyedParam {
-  readonly lru: Partial<LRUParam>;
+export interface KeyedParam<K, V> {
+  readonly lru: Partial<LRUParam<V, K>>;
 }
 
-export class Keyed<T extends { reset: () => void }, K = string> {
+type AddKeyedParam<K, V, CTX extends NonNullable<object>> = KeyedParam<K, V> & { readonly ctx: CTX };
+
+export class Keyed<T extends { reset: () => void }, K = string, CTX extends NonNullable<object> = object> {
   protected readonly _map: LRUMap<K, T>;
   // #lock = new ResolveSeq<T, K>();
+  readonly #ctx: CTX;
 
-  readonly factory: (key: K) => T;
-  constructor(factory: (key: K) => T, params: Partial<KeyedParam>) {
+  readonly factory: (ctx: AddKey<CTX, K>) => T;
+
+  constructor(factory: (ctx: AddKey<CTX, K>) => T, ctx: Partial<AddKeyedParam<K, T, CTX>>) {
+    this.#ctx = ctx.ctx || ({} as CTX);
     this.factory = factory;
-    this._map = new LRUMap<K, T>(params?.lru ?? { maxEntries: -1 });
+    this._map = new LRUMap<K, T>(ctx?.lru ?? ({ maxEntries: -1 } as LRUParam<T, K>));
   }
 
   onSet(fn: (key: K, value: T) => void): UnregFn {
@@ -414,7 +421,7 @@ export class Keyed<T extends { reset: () => void }, K = string> {
     return this._map.onDelete(fn);
   }
 
-  setParam(params: KeyedParam): void {
+  setParam(params: KeyedParam<K, T>): void {
     this._map.setParam(params.lru);
   }
 
@@ -428,7 +435,7 @@ export class Keyed<T extends { reset: () => void }, K = string> {
     }
     let keyed = this._map.get(key);
     if (!keyed) {
-      keyed = this.factory(key);
+      keyed = this.factory({ ...this.#ctx, key: key });
       this._map.set(key, keyed);
     }
     return keyed;
@@ -466,9 +473,9 @@ interface KeyItem<K, V> {
   readonly value: Result<V>;
 }
 
-export class KeyedResolvOnce<T, K = string> extends Keyed<ResolveOnce<T, K>, K> {
-  constructor(kp: Partial<KeyedParam> = {}) {
-    super((key) => new ResolveOnce<T, K>(key), kp);
+export class KeyedResolvOnce<T, K = string, CTX extends NonNullable<object> = object> extends Keyed<ResolveOnce<T, CTX>, K, CTX> {
+  constructor(kp: Partial<AddKeyedParam<K, ResolveOnce<T, CTX>, CTX>> = {}) {
+    super((ctx) => new ResolveOnce<T, AddKey<CTX, K>>(ctx), kp);
   }
 
   *entries(): IterableIterator<KeyItem<K, T>> {
@@ -493,9 +500,16 @@ export class KeyedResolvOnce<T, K = string> extends Keyed<ResolveOnce<T, K>, K>
   }
 }
 
-export class KeyedResolvSeq<T extends NonPromise<never>, K = string> extends Keyed<ResolveSeq<T, K>, K> {
-  constructor(kp: Partial<KeyedParam> = {}) {
-    super((key) => new ResolveSeq<T, K>(key), kp);
+type AddKey<X extends NonNullable<object>, K> = X & { key: K };
+type WithCTX<K, T, CTX extends NonNullable<object>> = KeyedParam<K, ResolveSeq<T, AddKey<CTX, K>>> & { readonly ctx: CTX };
+
+export class KeyedResolvSeq<T extends NonNullable<unknown>, K = string, CTX extends NonNullable<object> = object> extends Keyed<
+  ResolveSeq<T, AddKey<CTX, K>>,
+  K,
+  CTX
+> {
+  constructor(kp: Partial<WithCTX<K, T, CTX>> = {}) {
+    super((ctx) => new ResolveSeq<T, AddKey<CTX, K>>(ctx), kp);
   }
 }
 

package/src/sys-env.ts

@@ -5,6 +5,7 @@ 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";
+import { wrapImportMetaEnv, testInjectImportMetaEnv } from "@adviser/cement/import-meta-env";
 
 export type EnvTuple = ([string, string] | [string, string][] | Record<string, string> | Iterator<[string, string]>)[];
 
@@ -22,6 +23,7 @@ export interface EnvActions extends EnvMap {
 export interface EnvFactoryOpts {
   readonly symbol: string; // default "CP_ENV" used by BrowserEnvActions
   readonly presetEnv: Map<string, string>;
+  testPatchImportMetaEnv?: Record<string, string>;
   readonly id: string; // to reinit in tests
 }
 
@@ -66,8 +68,11 @@ export function envFactory(opts: Partial<EnvFactoryOpts> = {}): Env {
   if (!found) {
     throw new Error("SysContainer:envFactory: no env available");
   }
+
+  testInjectImportMetaEnv(opts.testPatchImportMetaEnv);
+
   return _envFactories.get(opts.id ?? found.id).once(() => {
-    const action = found.fn(opts);
+    const action = wrapImportMetaEnv(found.fn(opts));
     const ret = new EnvImpl(action, opts);
     action.register(ret);
     return ret;

package/src/utils/stripper.ts

@@ -12,20 +12,24 @@ export function stripper<T extends ArrayLike<S> | S, S>(
     }
     return s;
   });
-  return localStripper(undefined, restrips, obj) as T extends ArrayLike<unknown>
+  const selfRef = new WeakSet<object>();
+  return localStripper(undefined, restrips, obj, selfRef) as T extends ArrayLike<unknown>
     ? Record<string, unknown>[]
     : Record<string, unknown>;
 }
 
-function localStripper<T>(path: string | undefined, restrips: RegExp[], obj: T): unknown {
+function localStripper<T>(path: string | undefined, restrips: RegExp[], obj: T, selfRef: WeakSet<object>): unknown {
   if (typeof obj !== "object" || obj === null) {
     return obj;
   }
+  if (selfRef.has(obj)) {
+    return obj;
+  }
+  selfRef.add(obj);
   if (Array.isArray(obj)) {
-    return obj.map((i) => localStripper(path, restrips, i));
+    return obj.map((i) => localStripper(path, restrips, i, selfRef));
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const ret = { ...obj } as Record<string, any>;
+  const ret = { ...obj } as Record<string, unknown>;
   const matcher = (key: string, nextPath: string): boolean => {
     for (const re of restrips) {
       if (re.test(key) || re.test(nextPath)) {
@@ -49,16 +53,15 @@ function localStripper<T>(path: string | undefined, restrips: RegExp[], obj: T):
       }
       if (typeof ret[key] === "object") {
         if (Array.isArray(ret[key])) {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           ret[key] = ret[key].reduce((acc: unknown[], v, i) => {
             const toDelete = matcher(key, `${nextPath}[${i}]`);
             if (!toDelete) {
-              acc.push(localStripper(`${nextPath}[${i}]`, restrips, v));
+              acc.push(localStripper(`${nextPath}[${i}]`, restrips, v, selfRef));
             }
             return acc;
           }, []);
         } else {
-          ret[key] = localStripper(nextPath, restrips, ret[key]);
+          ret[key] = localStripper(nextPath, restrips, ret[key], selfRef);
         }
       }
     }

package/ts/cjs/cli/patch-version-cmd.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"patch-version-cmd.d.ts","sourceRoot":"","sources":["../../../../src/cli/patch-version-cmd.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAmC,MAAM,QAAQ,CAAC;AAmDlE,wBAAgB,oBAAoB,IAAI,UAAU,CAAC,OAAO,OAAO,CAAC,CAuCjE;AAmBD,wBAAgB,eAAe,IAAI,UAAU,CAAC,OAAO,OAAO,CAAC,CA+B5D;AAYD,wBAAgB,gBAAgB,IAAI,UAAU,CAAC,OAAO,OAAO,CAAC,CA6B7D;AAED,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAmFnH;AAED,wBAAgB,gBAAgB,IAAI,UAAU,CAAC,OAAO,OAAO,CAAC,CA2C7D"}
+{"version":3,"file":"patch-version-cmd.d.ts","sourceRoot":"","sources":["../../../../src/cli/patch-version-cmd.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAmC,MAAM,QAAQ,CAAC;AAkFlE,wBAAgB,oBAAoB,IAAI,UAAU,CAAC,OAAO,OAAO,CAAC,CAajE;AAmBD,wBAAgB,eAAe,IAAI,UAAU,CAAC,OAAO,OAAO,CAAC,CA+B5D;AAYD,wBAAgB,gBAAgB,IAAI,UAAU,CAAC,OAAO,OAAO,CAAC,CA6B7D;AAED,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAmFnH;AAED,wBAAgB,gBAAgB,IAAI,UAAU,CAAC,OAAO,OAAO,CAAC,CA2C7D"}