@xyo-network/module-model 5.3.20 → 5.3.24

package/src/instance/ModuleFilter.ts

@@ -1,33 +0,0 @@
-import type { ModuleInstance } from './Instance.ts'
-import type {
-  AddressObjectFilter,
-  AnyObjectFilter,
-  NameObjectFilter,
-  ObjectFilter,
-  ObjectFilterOptions,
-  QueryObjectFilter,
-} from './ObjectFilter.ts'
-import {
-  isAddressObjectFilter,
-  isNameObjectFilter,
-  isQueryObjectFilter,
-} from './ObjectFilter.ts'
-
-export interface ModuleFilterOptions<T extends ModuleInstance = ModuleInstance> extends ObjectFilterOptions<T> {}
-
-export const isAddressModuleFilter = isAddressObjectFilter<ModuleInstance>
-
-export const isNameModuleFilter = isNameObjectFilter<ModuleInstance>
-
-export const isQueryModuleFilter = isQueryObjectFilter<ModuleInstance>
-
-export type AnyModuleFilter<T extends ModuleInstance = ModuleInstance> = AnyObjectFilter<T>
-
-export type AddressModuleFilter<T extends ModuleInstance = ModuleInstance> = AddressObjectFilter<T>
-
-export type NameModuleFilter<T extends ModuleInstance = ModuleInstance> = NameObjectFilter<T>
-
-export type QueryModuleFilter<T extends ModuleInstance = ModuleInstance> = QueryObjectFilter<T>
-
-/** @deprecated use ModuleIdentifier instead */
-export type ModuleFilter<T extends ModuleInstance = ModuleInstance> = ObjectFilter<T>

package/src/instance/ModuleInstanceParams.ts

@@ -1,11 +0,0 @@
-import type { AnyConfigSchema, ModuleConfig } from '../Config/index.ts'
-import type { QueryableModuleParams } from '../QueryableModule/index.ts'
-import type { ModuleInstance } from './Instance.ts'
-
-export type ModuleInstanceChildrenParams = {
-  privateChildren?: ModuleInstance[]
-  publicChildren?: ModuleInstance[]
-}
-
-export interface ModuleInstanceParams<TConfig extends AnyConfigSchema<ModuleConfig> = AnyConfigSchema<ModuleConfig>> extends
-  QueryableModuleParams<TConfig>, ModuleInstanceChildrenParams {}

package/src/instance/ModuleRepository.ts

@@ -1,12 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-
-import type { ModuleInstance } from './Instance.ts'
-import type { ModuleResolverInstance } from './ModuleResolver.ts'
-
-export interface ModuleRepository<T extends ModuleInstance = ModuleInstance> extends ModuleResolverInstance<T> {
-  add(mod: T): this
-  add(mod: T[]): this
-  add(mod: T | T[]): this
-
-  remove(address: Address | string[]): this
-}

package/src/instance/ModuleResolver.ts

@@ -1,21 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-
-import type { ModuleIdentifier } from '../ModuleIdentifier.ts'
-import type { ModuleInstance } from './Instance.ts'
-import type { ObjectFilterOptions } from './ObjectFilter.ts'
-import type { ObjectResolver } from './ObjectResolver.ts'
-import { isObjectResolver } from './ObjectResolver.ts'
-
-export const isModuleResolver = isObjectResolver<ModuleInstance>
-
-export interface ModuleResolver<TResult extends ModuleInstance = ModuleInstance> extends ObjectResolver<TResult> {}
-
-export interface ModuleNameResolver {
-  readonly root: ModuleInstance
-  resolveIdentifier(id: ModuleIdentifier, options?: ObjectFilterOptions): Promisable<Address | undefined>
-}
-
-export interface ModuleResolverInstance<TResult extends ModuleInstance = ModuleInstance> extends ModuleResolver<TResult>, ModuleNameResolver {
-  addResolver: (resolver: ModuleResolverInstance<TResult>) => this
-  removeResolver: (resolver: ModuleResolverInstance<TResult>) => this
-}

package/src/instance/ObjectFilter.ts

@@ -1,48 +0,0 @@
-import type {
-  Address,
-  AnyObject, EmptyObject, TypeCheck,
-} from '@xylabs/sdk-js'
-
-import type { ModuleName } from '../ModuleIdentifier.ts'
-
-export type Direction = 'up' | 'down' | 'all'
-export type Visibility = 'public' | 'private' | 'all'
-
-export interface ResolveStrategy {
-  maxDepth?: number
-  required?: boolean | 'warn' | 'log'
-  retry?: number
-  timeout?: number
-}
-
-export interface ObjectFilterOptions<T extends EmptyObject = AnyObject> extends ResolveStrategy {
-  direction?: Direction
-  identity?: TypeCheck<T>
-}
-
-export interface AddressObjectFilter<T extends EmptyObject = AnyObject> extends ObjectFilterOptions<T> {
-  address: Address[]
-}
-
-export const isAddressObjectFilter = <T extends EmptyObject = AnyObject>(value: unknown): value is AddressObjectFilter<T> =>
-  (value as AddressObjectFilter<T>).address !== undefined
-
-export interface NameObjectFilter<T extends EmptyObject = AnyObject> extends ObjectFilterOptions<T> {
-  name: ModuleName[]
-}
-
-export const isNameObjectFilter = <T extends EmptyObject = AnyObject>(value: unknown): value is NameObjectFilter<T> =>
-  (value as NameObjectFilter<T>).name !== undefined
-
-export interface QueryObjectFilter<T extends EmptyObject = AnyObject> extends ObjectFilterOptions<T> {
-  query: string[][]
-}
-
-export const isQueryObjectFilter = <T extends EmptyObject = AnyObject>(value: unknown): value is QueryObjectFilter<T> =>
-  (value as QueryObjectFilter<T>).query !== undefined
-
-export type AnyObjectFilter<T extends EmptyObject = AnyObject> = Partial<AddressObjectFilter<T>>
-  & Partial<NameObjectFilter<T>>
-  & Partial<QueryObjectFilter<T>>
-
-export type ObjectFilter<T extends EmptyObject> = ObjectFilterOptions<T> | AddressObjectFilter<T> | NameObjectFilter<T> | QueryObjectFilter<T>

package/src/instance/ObjectResolver.ts

@@ -1,40 +0,0 @@
-import type {
-  AnyObject, EmptyObject, Promisable,
-} from '@xylabs/sdk-js'
-
-import type { ModuleIdentifier } from '../ModuleIdentifier.ts'
-import type { ObjectFilterOptions } from './ObjectFilter.ts'
-
-export const isObjectResolver = <T extends EmptyObject = AnyObject>(value?: unknown): value is ObjectResolver<T> => {
-  return typeof (value as Partial<ObjectResolver<T>>).resolve === 'function'
-}
-
-export const ObjectResolverPriority = {
-  Disabled: -1,
-  VeryLow: 0,
-  Low: 1,
-  Normal: 2,
-  High: 3,
-  VeryHigh: 4,
-} as const
-
-export type ObjectResolverPriority = typeof ObjectResolverPriority[keyof typeof ObjectResolverPriority]
-
-export interface ObjectResolver<TResult extends EmptyObject> {
-  priority: ObjectResolverPriority
-  resolve<T extends TResult = TResult>(all: '*', options?: ObjectFilterOptions<T>): Promisable<T[]>
-  resolve<T extends TResult = TResult>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promisable<T | undefined>
-  resolve<T extends TResult = TResult>(
-    id?: ModuleIdentifier,
-    options?: ObjectFilterOptions<T>,
-  ): Promisable<T | T[] | undefined>
-
-  resolvePrivate<T extends TResult = TResult>(all: '*', options?: ObjectFilterOptions<T>): Promise<T[]>
-  resolvePrivate<T extends TResult = TResult>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promise<T | undefined>
-  resolvePrivate<T extends TResult = TResult>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promise<T | T[] | undefined>
-}
-
-export interface ObjectResolverInstance<TResult extends EmptyObject> extends ObjectResolver<TResult> {
-  addResolver: (resolver: ObjectResolverInstance<TResult>) => this
-  removeResolver: (resolver: ObjectResolverInstance<TResult>) => this
-}

package/src/instance/asModuleInstance.ts

@@ -1,5 +0,0 @@
-import { AsObjectFactory } from '@xylabs/sdk-js'
-
-import { isModuleInstance } from './isModuleInstance.ts'
-
-export const asModuleInstance = AsObjectFactory.create(isModuleInstance)

package/src/instance/attachable/AttachableInstance.ts

@@ -1,25 +0,0 @@
-import type { CreatableInstance, TypeCheck } from '@xylabs/sdk-js'
-import { IsObjectFactory } from '@xylabs/sdk-js'
-
-import type { ModuleEventData } from '../../EventsModels/index.ts'
-import type { QueryableModuleParams } from '../../QueryableModule/index.ts'
-import type { ModuleInstance } from '../Instance.ts'
-import type { ModuleResolverInstance } from '../ModuleResolver.ts'
-
-export interface AttachableModuleInstance<TParams extends QueryableModuleParams = QueryableModuleParams, TEventData extends ModuleEventData = ModuleEventData>
-  extends ModuleInstance<TParams, TEventData>, CreatableInstance<TParams, TEventData> {
-  config: TParams['config']
-  /* The resolver is a 'down' resolver.  It can resolve the module or any children (if it is a node for example), that are in the module */
-  readonly downResolver: ModuleResolverInstance
-
-  // The resolver that gets called by children (usually only Nodes have this)
-  readonly privateResolver: ModuleResolverInstance
-
-  /* The resolver is a 'up' resolver.  It can resolve the parent or any children of the parent */
-  /* This is set by a NodeModule when attaching to the module */
-  readonly upResolver: ModuleResolverInstance
-}
-
-export type AttachableModuleInstanceTypeCheck<T extends AttachableModuleInstance = AttachableModuleInstance> = TypeCheck<T>
-
-export class IsAttachableModuleInstanceFactory<T extends AttachableModuleInstance = AttachableModuleInstance> extends IsObjectFactory<T> {}

package/src/instance/attachable/asAttachableInstance.ts

@@ -1,5 +0,0 @@
-import { AsObjectFactory } from '@xylabs/sdk-js'
-
-import { isAttachableModuleInstance } from './isAttachableInstance.ts'
-
-export const asAttachableModuleInstance = AsObjectFactory.create(isAttachableModuleInstance)

package/src/instance/attachable/index.ts

@@ -1,3 +0,0 @@
-export * from './asAttachableInstance.ts'
-export * from './AttachableInstance.ts'
-export * from './isAttachableInstance.ts'

package/src/instance/attachable/isAttachableInstance.ts

@@ -1,17 +0,0 @@
-import type { ObjectTypeShape, TypeCheck } from '@xylabs/sdk-js'
-import { IsObjectFactory } from '@xylabs/sdk-js'
-
-import { isModuleInstance } from '../isModuleInstance.ts'
-import type { AttachableModuleInstance } from './AttachableInstance.ts'
-
-export const requiredAttachableModuleInstanceFunctions: ObjectTypeShape = {
-  downResolver: 'object',
-  upResolver: 'object',
-}
-
-// we do not use IsInstanceFactory here to prevent a cycle
-const factory = new IsObjectFactory<AttachableModuleInstance>()
-
-export const isAttachableModuleInstance: TypeCheck<AttachableModuleInstance> = factory.create(requiredAttachableModuleInstanceFunctions, [
-  isModuleInstance,
-])

package/src/instance/index.ts

@@ -1,10 +0,0 @@
-export * from './asModuleInstance.ts'
-export * from './attachable/index.ts'
-export * from './Instance.ts'
-export * from './isModuleInstance.ts'
-export * from './ModuleFilter.ts'
-export * from './ModuleInstanceParams.ts'
-export * from './ModuleRepository.ts'
-export * from './ModuleResolver.ts'
-export * from './ObjectFilter.ts'
-export * from './ObjectResolver.ts'

package/src/instance/isModuleInstance.ts

@@ -1,15 +0,0 @@
-import type { ObjectTypeShape, TypeCheck } from '@xylabs/sdk-js'
-import { IsObjectFactory } from '@xylabs/sdk-js'
-
-import { isQueryableModule } from '../QueryableModule/index.ts'
-import type { ModuleInstance } from './Instance.ts'
-
-export const requiredModuleInstanceFunctions: ObjectTypeShape = {
-  manifest: 'function',
-  state: 'function',
-}
-
-// we do not use IsInstanceFactory here to prevent a cycle
-const factory = new IsObjectFactory<ModuleInstance>()
-
-export const isModuleInstance: TypeCheck<ModuleInstance> = factory.create(requiredModuleInstanceFunctions, [isQueryableModule])

package/src/lib/duplicateModules.ts

@@ -1,14 +0,0 @@
-import type { QueryableModule } from '../QueryableModule/index.ts'
-
-/**
- * Used to filter duplicates from an array of modules
- * @example: modulesArray.filter(duplicateModules)
- * @param value Current Module
- * @param index Current Module's index
- * @param array Module Array
- * @returns True if the Module's address is the first occurrence of
- * that address in the array, false otherwise
- */
-export const duplicateModules = (value: QueryableModule, index: number, array: QueryableModule[]): value is QueryableModule => {
-  return array.findIndex(v => v.address === value.address) === index
-}

package/src/lib/index.ts

@@ -1,2 +0,0 @@
-export * from './duplicateModules.ts'
-export * from './serializable.ts'

package/src/lib/serializable.ts

@@ -1,30 +0,0 @@
-export const isSerializable = (value: unknown, maxDepth = 10): boolean => {
-  if (maxDepth <= 0) {
-    return false
-  }
-  if (value === null || typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string') {
-    return true
-  }
-
-  if (Array.isArray(value)) {
-    return value.every(item => isSerializable(item, maxDepth - 1))
-  }
-
-  if (typeof value === 'object') {
-    if (value instanceof Date || value instanceof RegExp) {
-      return true
-    }
-
-    // Check for non-serializable objects like Set and Map
-    if (value instanceof Set || value instanceof Map) {
-      return false
-    }
-
-    if (value !== null && value !== undefined) {
-      return Object.values(value).every(item => isSerializable(item, maxDepth - 1))
-    }
-  }
-
-  // Exclude functions, symbols, undefined, and BigInt explicitly
-  return false
-}

package/src/withModule.ts

@@ -1,15 +0,0 @@
-import type { TypeCheck } from '@xylabs/sdk-js'
-
-/** @deprecated use narrowing instead [ if(is) ] */
-export const WithFactory = {
-  create: <T extends object>(typeCheck: TypeCheck<T>) => {
-    return <R>(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      mod: any,
-
-      closure: (mod: T) => R,
-    ): R | undefined => {
-      return typeCheck(mod) ? closure(mod) : undefined
-    }
-  },
-}