@rs-x/core 0.4.8 → 0.4.10

package/dist/index.d.ts

@@ -2,8 +2,8 @@ import { Container, Newable, ServiceIdentifier, BindToFluentSyntax, ContainerMod
 export { BindToFluentSyntax, Container, ContainerModule, ContainerModuleLoadOptions, inject as Inject, injectable as Injectable, multiInject as MultiInject, Newable, preDestroy as PreDestroy, ServiceIdentifier, unmanaged as Unmanaged } from 'inversify';
 import { Observable, Subject } from 'rxjs';
 
-interface IDeepCloneValueGetter {
-    get(source: unknown): unknown;
+interface IDeepCloneExcept {
+    except(source: unknown): unknown;
 }
 
 interface IResolvedValueCache {
@@ -12,44 +12,28 @@ interface IResolvedValueCache {
     delete(source: WeakKey): void;
 }
 
-declare class DeepCloneValueGetter implements IDeepCloneValueGetter {
+declare class DeepCloneValueExcept implements IDeepCloneExcept {
     private readonly _resolvedValueCache;
     constructor(_resolvedValueCache: IResolvedValueCache);
-    get(source: unknown): unknown;
+    except(source: unknown): unknown;
 }
 
-declare const InjectionContainer: Container;
-
-interface IMultiInjectTokens {
-    serviceToken?: symbol;
-    multiInjectToken: symbol;
-}
-interface IMultiInjectService {
-    target: Newable<unknown>;
-    token: symbol;
-}
-type BindMethod = <T>(serviceIdentifier: ServiceIdentifier<T>) => BindToFluentSyntax<T>;
-declare function registerMultiInjectService(container: Container | ContainerModuleLoadOptions, target: Newable<unknown>, options: IMultiInjectTokens): void;
-declare function registerMultiInjectServices(container: Container | ContainerModuleLoadOptions, multiInjectToken: symbol, services: readonly IMultiInjectService[]): void;
-declare function overrideMultiInjectServices(container: Container | ContainerModuleLoadOptions, multiInjectToken: symbol, services: readonly IMultiInjectService[]): void;
-
 interface IDeepClone {
     readonly priority: number;
     clone(source: unknown): unknown;
 }
 
-declare function DeepClone(serviceToken?: symbol): (target: Newable<IDeepClone>) => void;
-
 declare class DefaultDeepClone implements IDeepClone {
     private readonly _deepCloneList;
-    private readonly _deepCloneValueGetter;
     readonly priority = 0;
-    constructor(_deepCloneList: readonly IDeepClone[], _deepCloneValueGetter: IDeepCloneValueGetter);
+    constructor(_deepCloneList: readonly IDeepClone[]);
     clone(source: unknown): unknown;
 }
 
 declare class LodashDeepClone implements IDeepClone {
+    private readonly _deepCloneExcept;
     readonly priority = 1;
+    constructor(_deepCloneExcept: IDeepCloneExcept);
     clone(source: unknown): unknown;
     private cloneExceptPredicate;
 }
@@ -59,6 +43,21 @@ declare class StructuredDeepClone implements IDeepClone {
     clone(source: unknown): unknown;
 }
 
+declare const InjectionContainer: Container;
+
+interface IMultiInjectTokens {
+    serviceToken?: symbol;
+    multiInjectToken: symbol;
+}
+interface IMultiInjectService {
+    target: Newable<unknown>;
+    token: symbol;
+}
+type BindMethod = <T>(serviceIdentifier: ServiceIdentifier<T>) => BindToFluentSyntax<T>;
+declare function registerMultiInjectService(container: Container | ContainerModuleLoadOptions, target: Newable<unknown>, options: IMultiInjectTokens): void;
+declare function registerMultiInjectServices(container: Container | ContainerModuleLoadOptions, multiInjectToken: symbol, services: readonly IMultiInjectService[]): void;
+declare function overrideMultiInjectServices(container: Container | ContainerModuleLoadOptions, multiInjectToken: symbol, services: readonly IMultiInjectService[]): void;
+
 interface IEqualityService {
     isEqual(a: unknown, b: unknown): boolean;
 }
@@ -583,8 +582,8 @@ declare const RsXCoreInjectionTokens: {
     ILodashDeepClone: symbol;
     IDeepCloneList: symbol;
     IResolvedValueCache: symbol;
-    IDeepCloneValueGetter: symbol;
-    DefaultDeepCloneValueGetter: symbol;
+    IDeepCloneExcept: symbol;
+    DefaultDeepCloneExcept: symbol;
 };
 
 declare const defaultIndexValueAccessorList: readonly IMultiInjectService[];
@@ -613,4 +612,4 @@ declare class WaitForEvent<T extends {
     private unsubscribeEvent;
 }
 
-export { type AnyFunction, ArgumentException, ArrayIndexAccessor, Assertion, type BindMethod, type CheckValidKey, type ConstructorType, type DateProperty, DatePropertyAccessor, DeepClone, DeepCloneValueGetter, DefaultDeepClone, EqualityService, ErrorLog, FunctionCallIndex, FunctionCallIndexFactory, FunctionCallResultCacheFactory, type GetFunction, GuidFactory, type IArrayIndexAccessor, type IChainPart, type IDatePropertyAccessor, type IDeepClone, type IDeepCloneValueGetter, type IDisposable, type IDisposableFunctionCallIndex, type IDisposableOwner, type IEqualityService, type IError, type IErrorLog, type IFunctionCallIndex, type IFunctionCallIndexData, type IFunctionCallIndexFactory, type IFunctionCallResult, type IFunctionCallResultCache, type IFunctionCallResultCacheFactory, type IFunctionCallResultIdInfo, type IGuidFactory, type IISequenceWithIdData, type IIndexValueAccessor, type IMapKeyAccessor, type IMethodAccessor, type IMultiInjectService, type IMultiInjectTokens, type IObservableAccessor, type IPromiseAccessor, type IPropertyChange, type IPropertyDescriptor, type IPropertyValueAccessor, type IResolvedValueCache, type ISequenceIdFactory, type ISequenceWithId, type ISetKeyAccessor, type ISingletonFactory, type ISingletonFactoryWithIdGeneration, IndexValueAccessor, InjectionContainer, InvalidCastException, InvalidOperationException, type LastValuObservable, LodashDeepClone, MapKeyAccessor, MethodAccessor, NullOrEmptyException, NullOrUndefinedException, ObservableAccessor, PENDING, ParserException, PrettyPrinter, PromiseAccessor, PropertyDescriptorType, PropertyValueAccessor, ResolvedValueCache, RsXCoreInjectionTokens, RsXCoreModule, SequenceIdFactory, SequenceWithId, type SetFunction, SetKeyAccessor, SingletonFactory, SingletonFactoryWithGuid, SingletonFactoryWithIdGeneration, StructuredDeepClone, Type, UnexpectedException, UnsupportedException, WaitForEvent, dataProperties, defaultDeeoCloneList, defaultIndexValueAccessorList, echo, emptyFunction, emptyValue, overrideMultiInjectServices, printValue, registerMultiInjectService, registerMultiInjectServices, replaceSetItemAt, truePredicate, utCDate };
+export { type AnyFunction, ArgumentException, ArrayIndexAccessor, Assertion, type BindMethod, type CheckValidKey, type ConstructorType, type DateProperty, DatePropertyAccessor, DeepCloneValueExcept, DefaultDeepClone, EqualityService, ErrorLog, FunctionCallIndex, FunctionCallIndexFactory, FunctionCallResultCacheFactory, type GetFunction, GuidFactory, type IArrayIndexAccessor, type IChainPart, type IDatePropertyAccessor, type IDeepClone, type IDeepCloneExcept, type IDisposable, type IDisposableFunctionCallIndex, type IDisposableOwner, type IEqualityService, type IError, type IErrorLog, type IFunctionCallIndex, type IFunctionCallIndexData, type IFunctionCallIndexFactory, type IFunctionCallResult, type IFunctionCallResultCache, type IFunctionCallResultCacheFactory, type IFunctionCallResultIdInfo, type IGuidFactory, type IISequenceWithIdData, type IIndexValueAccessor, type IMapKeyAccessor, type IMethodAccessor, type IMultiInjectService, type IMultiInjectTokens, type IObservableAccessor, type IPromiseAccessor, type IPropertyChange, type IPropertyDescriptor, type IPropertyValueAccessor, type IResolvedValueCache, type ISequenceIdFactory, type ISequenceWithId, type ISetKeyAccessor, type ISingletonFactory, type ISingletonFactoryWithIdGeneration, IndexValueAccessor, InjectionContainer, InvalidCastException, InvalidOperationException, type LastValuObservable, LodashDeepClone, MapKeyAccessor, MethodAccessor, NullOrEmptyException, NullOrUndefinedException, ObservableAccessor, PENDING, ParserException, PrettyPrinter, PromiseAccessor, PropertyDescriptorType, PropertyValueAccessor, ResolvedValueCache, RsXCoreInjectionTokens, RsXCoreModule, SequenceIdFactory, SequenceWithId, type SetFunction, SetKeyAccessor, SingletonFactory, SingletonFactoryWithGuid, SingletonFactoryWithIdGeneration, StructuredDeepClone, Type, UnexpectedException, UnsupportedException, WaitForEvent, dataProperties, defaultDeeoCloneList, defaultIndexValueAccessorList, echo, emptyFunction, emptyValue, overrideMultiInjectServices, printValue, registerMultiInjectService, registerMultiInjectServices, replaceSetItemAt, truePredicate, utCDate };

package/dist/index.js

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// lib/deep-clone/deep-clone-value-getter.ts
+// lib/deep-clone/deep-clone-except.ts
 import { Observable } from "rxjs";
 
 // lib/dependency-injection.ts
@@ -68,11 +68,11 @@ var RsXCoreInjectionTokens = {
   ILodashDeepClone: Symbol("ILodashDeepClone"),
   IDeepCloneList: Symbol("IDeepCloneList"),
   IResolvedValueCache: Symbol("IResolvedValueCache"),
-  IDeepCloneValueGetter: Symbol("IDeepCloneValueGetter"),
-  DefaultDeepCloneValueGetter: Symbol("DefaultDeepCloneValueGetter")
+  IDeepCloneExcept: Symbol("IDeepCloneExcept"),
+  DefaultDeepCloneExcept: Symbol("DefaultDeepCloneExcept")
 };
 
-// lib/deep-clone/deep-clone-value-getter.ts
+// lib/deep-clone/deep-clone-except.ts
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -90,40 +90,29 @@ function _ts_param(paramIndex, decorator) {
   };
 }
 __name(_ts_param, "_ts_param");
-var DeepCloneValueGetter = class {
+var DeepCloneValueExcept = class {
   static {
-    __name(this, "DeepCloneValueGetter");
+    __name(this, "DeepCloneValueExcept");
   }
   _resolvedValueCache;
   constructor(_resolvedValueCache) {
     this._resolvedValueCache = _resolvedValueCache;
   }
-  get(source) {
+  except(source) {
     if (source instanceof Promise || source instanceof Observable) {
       return this._resolvedValueCache.get(source);
     }
-    return source;
+    return void 0;
   }
 };
-DeepCloneValueGetter = _ts_decorate([
+DeepCloneValueExcept = _ts_decorate([
   injectable(),
   _ts_param(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
   ])
-], DeepCloneValueGetter);
-
-// lib/deep-clone/deep-clone.decorator.ts
-function DeepClone(serviceToken) {
-  return function(target) {
-    registerMultiInjectService(InjectionContainer, target, {
-      serviceToken,
-      multiInjectToken: RsXCoreInjectionTokens.IDeepCloneList
-    });
-  };
-}
-__name(DeepClone, "DeepClone");
+], DeepCloneValueExcept);
 
 // lib/deep-clone/default-deep-clone.ts
 function _ts_decorate2(decorators, target, key, desc) {
@@ -148,18 +137,15 @@ var DefaultDeepClone = class {
     __name(this, "DefaultDeepClone");
   }
   _deepCloneList;
-  _deepCloneValueGetter;
   priority = 0;
-  constructor(_deepCloneList, _deepCloneValueGetter) {
+  constructor(_deepCloneList) {
     this._deepCloneList = _deepCloneList;
-    this._deepCloneValueGetter = _deepCloneValueGetter;
   }
   clone(source) {
     let error = null;
-    const value = this._deepCloneValueGetter.get(source);
     for (let i = 0; i < this._deepCloneList.length; i++) {
       try {
-        return this._deepCloneList[i].clone(value);
+        return this._deepCloneList[i].clone(source);
       } catch (e) {
         error = e;
       }
@@ -170,17 +156,14 @@ var DefaultDeepClone = class {
 DefaultDeepClone = _ts_decorate2([
   injectable(),
   _ts_param2(0, multiInject(RsXCoreInjectionTokens.IDeepCloneList)),
-  _ts_param2(1, inject(RsXCoreInjectionTokens.IDeepCloneValueGetter)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
-    Object,
-    typeof IDeepCloneValueGetter === "undefined" ? Object : IDeepCloneValueGetter
+    Object
   ])
 ], DefaultDeepClone);
 
 // lib/deep-clone/lodash-deep-clone.ts
 import cloneDeepWith from "lodash.clonedeepwith";
-import { isObservable } from "rxjs";
 function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -188,23 +171,39 @@ function _ts_decorate3(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
 var LodashDeepClone = class {
   static {
     __name(this, "LodashDeepClone");
   }
+  _deepCloneExcept;
   priority = 1;
+  constructor(_deepCloneExcept) {
+    this._deepCloneExcept = _deepCloneExcept;
+  }
   clone(source) {
     return cloneDeepWith(source, this.cloneExceptPredicate);
   }
   cloneExceptPredicate = /* @__PURE__ */ __name((value) => {
-    if (value instanceof Promise || isObservable(value)) {
-      return value;
-    }
-    return void 0;
+    return this._deepCloneExcept.except(value);
   }, "cloneExceptPredicate");
 };
 LodashDeepClone = _ts_decorate3([
-  injectable()
+  injectable(),
+  _ts_param3(0, inject(RsXCoreInjectionTokens.DefaultDeepCloneExcept)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof IDeepCloneExcept === "undefined" ? Object : IDeepCloneExcept
+  ])
 ], LodashDeepClone);
 
 // lib/deep-clone/structured-deep-clone.ts
@@ -230,7 +229,7 @@ StructuredDeepClone = _ts_decorate4([
 
 // lib/equality-service/equality-service.ts
 import { createCustomEqual } from "fast-equals";
-import { isObservable as isObservable2 } from "rxjs";
+import { isObservable } from "rxjs";
 function _ts_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -246,7 +245,7 @@ var EqualityService = class {
     createCustomConfig: /* @__PURE__ */ __name((baseConfig) => ({
       ...baseConfig,
       areObjectsEqual: /* @__PURE__ */ __name((a, b, equalityCheck) => {
-        if (isObservable2(a) && isObservable2(b)) {
+        if (isObservable(a) && isObservable(b)) {
           return a === b;
         }
         return baseConfig.areObjectsEqual(a, b, equalityCheck);
@@ -267,10 +266,10 @@ function _ts_decorate6(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate6, "_ts_decorate");
-function _ts_metadata3(k, v) {
+function _ts_metadata4(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata3, "_ts_metadata");
+__name(_ts_metadata4, "_ts_metadata");
 var ErrorLog = class {
   static {
     __name(this, "ErrorLog");
@@ -292,8 +291,8 @@ var ErrorLog = class {
 };
 ErrorLog = _ts_decorate6([
   injectable(),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [])
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [])
 ], ErrorLog);
 
 // lib/error-log/pretty-printer.ts
@@ -750,10 +749,10 @@ function _ts_decorate7(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate7, "_ts_decorate");
-function _ts_metadata4(k, v) {
+function _ts_metadata5(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata4, "_ts_metadata");
+__name(_ts_metadata5, "_ts_metadata");
 var SingletonFactory = class {
   static {
     __name(this, "SingletonFactory");
@@ -899,9 +898,9 @@ var SingletonFactory = class {
 };
 _ts_decorate7([
   preDestroy(),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", []),
-  _ts_metadata4("design:returntype", void 0)
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", []),
+  _ts_metadata5("design:returntype", void 0)
 ], SingletonFactory.prototype, "dispose", null);
 
 // lib/function-call-index/function-call-index.ts
@@ -950,16 +949,16 @@ function _ts_decorate8(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate8, "_ts_decorate");
-function _ts_metadata5(k, v) {
+function _ts_metadata6(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata5, "_ts_metadata");
-function _ts_param3(paramIndex, decorator) {
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param3, "_ts_param");
+__name(_ts_param4, "_ts_param");
 var FunctionCallIndexFactory = class extends SingletonFactory {
   static {
     __name(this, "FunctionCallIndexFactory");
@@ -991,9 +990,9 @@ var FunctionCallIndexFactory = class extends SingletonFactory {
 };
 FunctionCallIndexFactory = _ts_decorate8([
   injectable(),
-  _ts_param3(0, inject(RsXCoreInjectionTokens.ISequenceIdFactory)),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_param4(0, inject(RsXCoreInjectionTokens.ISequenceIdFactory)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
     typeof ISequenceIdFactory === "undefined" ? Object : ISequenceIdFactory
   ])
 ], FunctionCallIndexFactory);
@@ -1006,16 +1005,16 @@ function _ts_decorate9(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate9, "_ts_decorate");
-function _ts_metadata6(k, v) {
+function _ts_metadata7(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata6, "_ts_metadata");
-function _ts_param4(paramIndex, decorator) {
+__name(_ts_metadata7, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param4, "_ts_param");
+__name(_ts_param5, "_ts_param");
 var FunctionCallResultCache = class FunctionCallResultCache2 {
   static {
     __name(this, "FunctionCallResultCache");
@@ -1118,9 +1117,9 @@ var FunctionCallResultCacheFactory = class {
 };
 FunctionCallResultCacheFactory = _ts_decorate9([
   injectable(),
-  _ts_param4(0, inject(RsXCoreInjectionTokens.IFunctionCallIndexFactory)),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [
+  _ts_param5(0, inject(RsXCoreInjectionTokens.IFunctionCallIndexFactory)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
     typeof IFunctionCallIndexFactory === "undefined" ? Object : IFunctionCallIndexFactory
   ])
 ], FunctionCallResultCacheFactory);
@@ -1284,16 +1283,16 @@ function _ts_decorate13(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate13, "_ts_decorate");
-function _ts_metadata7(k, v) {
+function _ts_metadata8(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata7, "_ts_metadata");
-function _ts_param5(paramIndex, decorator) {
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param5, "_ts_param");
+__name(_ts_param6, "_ts_param");
 var IndexValueAccessor = class {
   static {
     __name(this, "IndexValueAccessor");
@@ -1340,9 +1339,9 @@ var IndexValueAccessor = class {
 };
 IndexValueAccessor = _ts_decorate13([
   injectable(),
-  _ts_param5(0, multiInject(RsXCoreInjectionTokens.IIndexValueAccessorList)),
-  _ts_metadata7("design:type", Function),
-  _ts_metadata7("design:paramtypes", [
+  _ts_param6(0, multiInject(RsXCoreInjectionTokens.IIndexValueAccessorList)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
     Object
   ])
 ], IndexValueAccessor);
@@ -1394,16 +1393,16 @@ function _ts_decorate15(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate15, "_ts_decorate");
-function _ts_metadata8(k, v) {
+function _ts_metadata9(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata8, "_ts_metadata");
-function _ts_param6(paramIndex, decorator) {
+__name(_ts_metadata9, "_ts_metadata");
+function _ts_param7(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param6, "_ts_param");
+__name(_ts_param7, "_ts_param");
 var MethodAccessor = class {
   static {
     __name(this, "MethodAccessor");
@@ -1441,15 +1440,15 @@ var MethodAccessor = class {
 };
 MethodAccessor = _ts_decorate15([
   injectable(),
-  _ts_param6(0, inject(RsXCoreInjectionTokens.IFunctionCallResultCacheFactory)),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
+  _ts_param7(0, inject(RsXCoreInjectionTokens.IFunctionCallResultCacheFactory)),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
     typeof IFunctionCallResultCacheFactory === "undefined" ? Object : IFunctionCallResultCacheFactory
   ])
 ], MethodAccessor);
 
 // lib/index-value-accessor/observable-accessor.ts
-import { BehaviorSubject, isObservable as isObservable3, Subject as Subject2 } from "rxjs";
+import { BehaviorSubject, isObservable as isObservable2, Subject as Subject2 } from "rxjs";
 
 // lib/types/set.ts
 function replaceSetItemAt(set, oldValue, newValue) {
@@ -1482,16 +1481,16 @@ function _ts_decorate16(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate16, "_ts_decorate");
-function _ts_metadata9(k, v) {
+function _ts_metadata10(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata9, "_ts_metadata");
-function _ts_param7(paramIndex, decorator) {
+__name(_ts_metadata10, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param7, "_ts_param");
+__name(_ts_param8, "_ts_param");
 var ObservableAccessor = class {
   static {
     __name(this, "ObservableAccessor");
@@ -1531,7 +1530,7 @@ var ObservableAccessor = class {
   }
   applies(context, index) {
     const val = this.getIndexedValue(context, index);
-    return isObservable3(val);
+    return isObservable2(val);
   }
   setLastValue(observable, value) {
     this._resolvedValueCache.set(observable, value);
@@ -1545,9 +1544,9 @@ var ObservableAccessor = class {
 };
 ObservableAccessor = _ts_decorate16([
   injectable(),
-  _ts_param7(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
+  _ts_param8(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
     typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
   ])
 ], ObservableAccessor);
@@ -1560,16 +1559,16 @@ function _ts_decorate17(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate17, "_ts_decorate");
-function _ts_metadata10(k, v) {
+function _ts_metadata11(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata10, "_ts_metadata");
-function _ts_param8(paramIndex, decorator) {
+__name(_ts_metadata11, "_ts_metadata");
+function _ts_param9(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param8, "_ts_param");
+__name(_ts_param9, "_ts_param");
 var PromiseAccessor = class {
   static {
     __name(this, "PromiseAccessor");
@@ -1618,15 +1617,15 @@ var PromiseAccessor = class {
 };
 PromiseAccessor = _ts_decorate17([
   injectable(),
-  _ts_param8(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
-  _ts_metadata10("design:type", Function),
-  _ts_metadata10("design:paramtypes", [
+  _ts_param9(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
     typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
   ])
 ], PromiseAccessor);
 
 // lib/index-value-accessor/property-value-accessor.ts
-import { isObservable as isObservable4 } from "rxjs";
+import { isObservable as isObservable3 } from "rxjs";
 var PropertyValueAccessor = class {
   static {
     __name(this, "PropertyValueAccessor");
@@ -1664,7 +1663,7 @@ var PropertyValueAccessor = class {
     if (!obj) {
       return false;
     }
-    return Type.hasProperty(obj, index) && !(obj instanceof Date) && !isObservable4(obj[index]) && !(obj[index] instanceof Promise);
+    return Type.hasProperty(obj, index) && !(obj instanceof Date) && !isObservable3(obj[index]) && !(obj[index] instanceof Promise);
   }
 };
 
@@ -1813,16 +1812,16 @@ function _ts_decorate20(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate20, "_ts_decorate");
-function _ts_metadata11(k, v) {
+function _ts_metadata12(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata11, "_ts_metadata");
-function _ts_param9(paramIndex, decorator) {
+__name(_ts_metadata12, "_ts_metadata");
+function _ts_param10(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param9, "_ts_param");
+__name(_ts_param10, "_ts_param");
 var RegistryNode = class RegistryNode2 {
   static {
     __name(this, "RegistryNode");
@@ -2001,15 +2000,15 @@ var SequenceIdFactory = class {
 };
 _ts_decorate20([
   preDestroy(),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", []),
-  _ts_metadata11("design:returntype", void 0)
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", []),
+  _ts_metadata12("design:returntype", void 0)
 ], SequenceIdFactory.prototype, "dispose", null);
 SequenceIdFactory = _ts_decorate20([
   injectable(),
-  _ts_param9(0, inject(RsXCoreInjectionTokens.IGuidFactory)),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+  _ts_param10(0, inject(RsXCoreInjectionTokens.IGuidFactory)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof IGuidFactory === "undefined" ? Object : IGuidFactory
   ])
 ], SequenceIdFactory);
@@ -2070,8 +2069,8 @@ var RsXCoreModule = new ContainerModule((options) => {
   options.bind(RsXCoreInjectionTokens.IFunctionCallResultCacheFactory).to(FunctionCallResultCacheFactory).inSingletonScope();
   options.bind(RsXCoreInjectionTokens.IGuidFactory).to(GuidFactory).inSingletonScope();
   options.bind(RsXCoreInjectionTokens.IResolvedValueCache).to(ResolvedValueCache).inSingletonScope();
-  options.bind(RsXCoreInjectionTokens.IDeepCloneValueGetter).to(DeepCloneValueGetter).inSingletonScope();
-  options.bind(RsXCoreInjectionTokens.DefaultDeepCloneValueGetter).to(DeepCloneValueGetter).inSingletonScope();
+  options.bind(RsXCoreInjectionTokens.IDeepCloneExcept).to(DeepCloneValueExcept).inSingletonScope();
+  options.bind(RsXCoreInjectionTokens.DefaultDeepCloneExcept).to(DeepCloneValueExcept).inSingletonScope();
   registerMultiInjectServices(options, RsXCoreInjectionTokens.IIndexValueAccessorList, defaultIndexValueAccessorList);
   registerMultiInjectServices(options, RsXCoreInjectionTokens.IDeepCloneList, defaultDeeoCloneList);
 });
@@ -2162,8 +2161,7 @@ export {
   Container,
   ContainerModule,
   DatePropertyAccessor,
-  DeepClone,
-  DeepCloneValueGetter,
+  DeepCloneValueExcept,
   DefaultDeepClone,
   EqualityService,
   ErrorLog,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rs-x/core",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "Core reactive primitives, dependency injection, and state foundations for the RS-X framework",
   "type": "module",
   "main": "./dist/index.js",