@xyo-network/module-model 2.107.5 → 2.108.0

package/src/ResolveHelper/resolveLocalNameToInstance.ts

@@ -11,7 +11,7 @@ export const resolveLocalNameToInstanceUp = async (root: ModuleInstance, modName
 export const resolveLocalNameToInstanceDown = async (
   root: ModuleInstance,
   modName: ModuleName,
-  includePrivate = false,
+  includePrivate: boolean | undefined = undefined,
 ): Promise<ModuleInstance | undefined> => {
   const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? []
   const publicChildren = (await root.publicChildren?.()) ?? []

package/src/ResolveHelper/resolvePathToAddress.ts

@@ -8,7 +8,7 @@ import { resolvePathToInstance } from './resolvePathToInstance'
 export const resolvePathToAddress = async (
   root: ModuleInstance,
   path: string,
-  includePrivate = false,
+  includePrivate: boolean | undefined = undefined,
   transformers: ModuleIdentifierTransformer[] = ResolveHelperStatic.transformers,
 ): Promise<Address | undefined> => {
   return (await resolvePathToInstance(root, path, includePrivate, transformers))?.address

package/src/ResolveHelper/resolvePathToInstance.ts

@@ -12,7 +12,7 @@ import { transformModuleIdentifier } from './transformModuleIdentifier'
 export const resolvePathToInstance = async (
   root: ModuleInstance,
   path: string,
-  includePrivate = false,
+  includePrivate: boolean | undefined = undefined,
   transformers: ModuleIdentifierTransformer[] = ResolveHelperStatic.transformers,
 ): Promise<ModuleInstance | undefined> => {
   const parts = path.split(MODULE_PATH_SEPARATOR)

package/src/instance/Instance.ts

@@ -34,7 +34,7 @@ export interface AddressToWeakInstanceCache {
 
 export interface ModuleFamilyFunctions {
   account?: AccountInstance | undefined
-  addParent: (module: ModuleInstance) => void
+  addParent: (mod: ModuleInstance) => void
   addressCache?: (direction: Direction, includePrivate: boolean) => AddressToWeakInstanceCache | undefined
   modName?: ModuleName
   parents: () => Promisable<ModuleInstance[]>

package/src/instance/ModuleRepository.ts

@@ -4,9 +4,9 @@ import { ModuleInstance } from './Instance'
 import { ModuleResolverInstance } from './ModuleResolver'
 
 export interface ModuleRepository<T extends ModuleInstance = ModuleInstance> extends ModuleResolverInstance<T> {
-  add(module: T): this
-  add(module: T[]): this
-  add(module: T | T[]): this
+  add(mod: T): this
+  add(mod: T[]): this
+  add(mod: T | T[]): this
 
   remove(address: Address | string[]): this
 }

package/src/instance/ObjectResolver.ts

@@ -5,6 +5,7 @@ import { ModuleIdentifier } from '../ModuleIdentifier'
 import { ObjectFilter, ObjectFilterOptions } from './ObjectFilter'
 
 export const isObjectResolver = <T extends EmptyObject = AnyObject>(value?: unknown): value is ObjectResolver<T> => {
+  // eslint-disable-next-line deprecation/deprecation
   return typeof (value as Partial<ObjectResolver<T>>).resolve === 'function'
 }
 

package/src/module/IsModuleFactory.ts

@@ -10,10 +10,10 @@ export type ModuleTypeCheck<T extends Module = Module> = TypeCheck<T>
 export class IsModuleFactory<T extends Module = Module> {
   create(expectedQueries?: string[], additionalChecks?: TypeCheck<AnyObject | EmptyObject>[]): ModuleTypeCheck<T> {
     return (obj: AnyNonPromise, config): obj is T => {
-      const module = asModuleObject(obj)
+      const mod = asModuleObject(obj)
       const result =
-        isModuleObject(module, config) &&
-        (expectedQueries?.reduce((prev, query) => prev && module.queries.includes(query), true) ?? true) &&
+        isModuleObject(mod, config) &&
+        (expectedQueries?.reduce((prev, query) => prev && mod.queries.includes(query), true) ?? true) &&
         //perform additional checks
         (additionalChecks?.reduce((prev, check) => prev && check(obj, config), true) ?? true)
       return result

package/src/withModule.ts

@@ -7,11 +7,11 @@ export const WithFactory = {
   create: <T extends object>(typeCheck: TypeCheck<T>) => {
     return <R>(
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      module: any,
+      mod: any,
 
-      closure: (module: T) => R,
+      closure: (mod: T) => R,
     ): R | undefined => {
-      return typeCheck(module) ? closure(module) : undefined
+      return typeCheck(mod) ? closure(mod) : undefined
     }
   },
 }