@xyo-network/xl1-protocol-sdk 1.26.12 → 1.26.14

package/src/CreatableProvider/CreatableProvider.ts

@@ -1,102 +0,0 @@
-import type {
-  Creatable, CreatableInstance, CreatableParams,
-  EventData,
-  Labels, WithOptionalLabels,
-} from '@xylabs/sdk-js'
-import type { Provider, ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderContext } from '../model/index.ts'
-import type { GetInstanceOptions } from './GetInstanceOptions.ts'
-import type { LabeledCreatableProviderFactory } from './LabeledCreatableProviderFactory.ts'
-
-/** Parameters for CreatableProvider. */
-export interface CreatableProviderParams<TContext extends CreatableProviderContext = CreatableProviderContext> extends CreatableParams {
-  context: TContext
-}
-/** CreatableProviderEventData interface. */
-export interface CreatableProviderEventData extends EventData {}
-
-/** CreatableProviderInstance type. */
-export type CreatableProviderInstance<
-  TProvider extends Provider<ProviderMoniker> = Provider<ProviderMoniker>,
-  TDependencies extends ProviderMoniker[] = ProviderMoniker[],
-  TParams extends CreatableProviderParams = CreatableProviderParams,
-  TEventData extends CreatableProviderEventData = CreatableProviderEventData>
-  = CreatableInstance<TParams, TEventData> & TProvider & {
-    dependencies: ProviderMap<TDependencies[number]>
-  }
-
-/** ProviderFactoryScope type. */
-export type ProviderFactoryScope = 'global' | 'context' | 'local'
-
-/** CreatableProviderFactory interface. */
-export interface CreatableProviderFactory<T extends CreatableProviderInstance = CreatableProviderInstance,
-  TDependencies extends ProviderMoniker[] = ProviderMoniker[]>
-  extends Omit<CreatableProvider<T>, 'create' | 'createHandler' | 'paramsHandler'> {
-  creatableProvider: CreatableProvider<T>
-  defaultParams: Omit<T['params'], 'context'>
-
-  readonly dependencies: TDependencies
-
-  labels?: Labels
-  providerName: string
-  resolvedMoniker: string
-  scope: ProviderFactoryScope
-
-  uniqueId: symbol
-
-  getInstance(
-    this: CreatableProviderFactory<T>,
-    params: T['params'],
-    options?: GetInstanceOptions): Promise<T>
-
-  tryGetInstance(
-    this: CreatableProviderFactory<T>,
-    params: T['params'],
-    options?: GetInstanceOptions): Promise<T | undefined>
-
-}
-
-/** LabeledCreatableProvider interface. */
-export interface LabeledCreatableProvider<T extends CreatableProviderInstance = CreatableProviderInstance,
-  TDependencies extends ProviderMoniker[] = ProviderMoniker[]> extends CreatableProvider<T>, WithOptionalLabels {
-  factory(dependencies: TDependencies, params: Omit<T['params'], 'context'>): LabeledCreatableProviderFactory<T>
-}
-
-/** ProviderMap type. */
-export type ProviderMap<T extends ProviderMoniker = ProviderMoniker> = Partial<Record<T, CreatableProviderInstance<Provider<T>>>>
-
-/** CreatableProvider interface. */
-export interface CreatableProvider<T extends CreatableProviderInstance = CreatableProviderInstance,
-  TDependencies extends ProviderMoniker[] = ProviderMoniker[]> extends Creatable<T> {
-  readonly defaultMoniker: ProviderMoniker
-  readonly dependencies: TDependencies
-  readonly monikers: ProviderMoniker[]
-  factory(dependencies: TDependencies, params: Omit<T['params'], 'context'>): CreatableProviderFactory<T>
-}
-
-/**
- * Class annotation to be used to decorate Providers which support
- * an asynchronous creation pattern
- * @returns The decorated Provider requiring it implement the members
- * of the CreatableProvider as statics properties/methods
- */
-export function creatableProvider<TProvider extends CreatableProviderInstance = CreatableProviderInstance>() {
-  return <U extends CreatableProvider<TProvider>>(constructor: U) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    constructor
-  }
-}
-
-/**
- * Class annotation to be used to decorate Providers which support
- * an asynchronous creation pattern
- * @returns The decorated Provider requiring it implement the members
- * of the CreatableProvider as statics properties/methods
- */
-export function labeledCreatableProvider<TProvider extends CreatableProviderInstance = CreatableProviderInstance>() {
-  return <U extends LabeledCreatableProvider<TProvider>>(constructor: U) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    constructor
-  }
-}

package/src/CreatableProvider/CreatableProviderRegistry.ts

@@ -1,94 +0,0 @@
-import type { Labels } from '@xylabs/sdk-js'
-import { isTruthy } from '@xylabs/sdk-js'
-import type { ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderFactory, CreatableProviderInstance } from './CreatableProvider.ts'
-import type { LabeledCreatableProviderFactory } from './LabeledCreatableProviderFactory.ts'
-import { providerFactoryDescription } from './ProviderFactory.ts'
-
-/** CreatableProviderRegistry type. */
-export type CreatableProviderRegistry<TMonikers extends ProviderMoniker[] = ProviderMoniker[]>
-  = Record<TMonikers[number], (CreatableProviderFactory | LabeledCreatableProviderFactory)[] | undefined>
-
-const buildProviderFactory = <TProvider extends CreatableProviderInstance>(
-  provider: CreatableProviderFactory<TProvider>,
-  defaultParams: Omit<TProvider['params'], 'context'>,
-  labels?: Labels,
-): LabeledCreatableProviderFactory<TProvider> => {
-  const factory = {
-    monikers: provider.monikers,
-    uniqueId: Symbol(providerFactoryDescription(provider, labels)),
-    // Merge module & supplied labels
-    labels: { ...(provider as LabeledCreatableProviderFactory).labels, ...labels },
-    creatableProvider: provider.creatableProvider,
-    dependencies: provider.dependencies,
-    resolvedMoniker: provider.resolvedMoniker,
-    providerName: provider.providerName,
-    scope: provider.scope,
-    defaultParams,
-    getInstance: provider.getInstance.bind(provider) as LabeledCreatableProviderFactory<TProvider>['getInstance'],
-    tryGetInstance: provider.tryGetInstance?.bind(provider) as LabeledCreatableProviderFactory<TProvider>['tryGetInstance'],
-    defaultMoniker: provider.defaultMoniker,
-    factory: provider.factory.bind(provider) as LabeledCreatableProviderFactory<TProvider>['factory'],
-  } satisfies LabeledCreatableProviderFactory<TProvider>
-  return factory
-}
-
-/** registerCreatableProviderFactory constant. */
-export const registerCreatableProviderFactory = <TProvider extends CreatableProviderInstance>(
-  registry: CreatableProviderRegistry,
-  factory: CreatableProviderFactory<TProvider> | LabeledCreatableProviderFactory<TProvider>,
-  labels?: Labels,
-  /** register this as the primary factory for every schema it supports */
-  primary: boolean | ProviderMoniker | ProviderMoniker[] = false,
-) => {
-  const primaryMonikers
-    = primary !== true && isTruthy(primary)
-      ? Array.isArray(primary)
-        ? primary
-        : [primary]
-      : []
-
-  for (const primaryMoniker of primaryMonikers) {
-    if (!factory.monikers.includes(primaryMoniker)) {
-      console.warn(`Primary moniker ${primary} not found in factory monikers`)
-    }
-  }
-
-  const isPrimaryForMoniker = (moniker: ProviderMoniker) => {
-    switch (typeof primary) {
-      case 'boolean': {
-        return primary
-      }
-      case 'string': {
-        return moniker === primary
-      }
-      case 'object': {
-        if (Array.isArray(primary)) {
-          return primary.includes(moniker)
-        }
-      }
-    }
-    throw new Error(`Invalid primary value: ${primary}`)
-  }
-
-  const factoryClone: LabeledCreatableProviderFactory<TProvider> = buildProviderFactory(factory, factory.defaultParams, labels)
-
-  // add this default moniker as the first entry
-  registry[factoryClone.defaultMoniker] = [factoryClone, ...(registry[factoryClone.defaultMoniker] ?? [])]
-  for (const moniker of factoryClone.monikers) {
-    registry[moniker] = isPrimaryForMoniker(moniker) ? [factoryClone, ...(registry[moniker] ?? [])] : [...(registry[moniker] ?? []), factoryClone]
-  }
-}
-
-/** registerCreatableProviderFactories constant. */
-export const registerCreatableProviderFactories = (
-  factories: (CreatableProviderFactory | LabeledCreatableProviderFactory)[],
-  registry: CreatableProviderRegistry = {},
-  primary = false,
-) => {
-  for (const factory of factories) {
-    registerCreatableProviderFactory(registry, factory, undefined, primary)
-  }
-  return registry
-}

package/src/CreatableProvider/GetInstanceOptions.ts

@@ -1,11 +0,0 @@
-import type { Labels } from '@xylabs/sdk-js'
-
-/** Options for GetInstance. */
-export interface GetInstanceOptions {
-  start?: boolean
-}
-
-/** Options for ProviderFactoryGetInstance. */
-export interface ProviderFactoryGetInstanceOptions extends GetInstanceOptions {
-  labels?: Labels
-}

package/src/CreatableProvider/LabeledCreatableProviderFactory.ts

@@ -1,24 +0,0 @@
-import type { WithOptionalLabels } from '@xylabs/sdk-js'
-
-import type { CreatableProviderFactory, CreatableProviderInstance } from './CreatableProvider.ts'
-
-/** LabeledCreatableProviderFactory type. */
-export type LabeledCreatableProviderFactory<T extends CreatableProviderInstance = CreatableProviderInstance> = CreatableProviderFactory<T> & WithOptionalLabels
-
-/** hasLabels constant. */
-export const hasLabels = (factory: CreatableProviderFactory | LabeledCreatableProviderFactory): factory is LabeledCreatableProviderFactory => {
-  return (factory as LabeledCreatableProviderFactory).labels !== undefined
-}
-
-/**
- * Class annotation to be used to decorate Providers which support
- * an asynchronous labeled creation factory pattern
- * @returns The decorated Provider requiring it implement the members
- * of the CreatableProvider as statics properties/methods
- */
-export function labeledCreatableProviderFactory<TProvider extends CreatableProviderInstance = CreatableProviderInstance>() {
-  return <U extends LabeledCreatableProviderFactory<TProvider>>(constructor: U) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    constructor
-  }
-}

package/src/CreatableProvider/ProviderFactory.ts

@@ -1,138 +0,0 @@
-import type { Labels, WithOptionalLabels } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type { ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type {
-  CreatableProvider, CreatableProviderFactory, CreatableProviderInstance,
-  ProviderFactoryScope,
-} from './CreatableProvider.ts'
-import type { GetInstanceOptions } from './GetInstanceOptions.ts'
-
-declare global {
-  var xyoServiceSingletons: Record<string, unknown>
-}
-
-/** ProviderFactoryDescription helper function. */
-export function providerFactoryDescription(factory: CreatableProviderFactory, labels?: Labels) {
-  return `${factory.providerName}:${factory.defaultMoniker}:${JSON.stringify(labels ?? (factory as WithOptionalLabels).labels ?? {})}`
-}
-
-/** ProviderFactory implementation. */
-export class ProviderFactory<TProvider extends CreatableProviderInstance,
-  TDependencies extends ProviderMoniker[]> implements CreatableProviderFactory<TProvider> {
-  creatableProvider: CreatableProvider<TProvider>
-
-  defaultMoniker: CreatableProvider<TProvider>['monikers'][number]
-
-  defaultParams: Omit<TProvider['params'], 'context'>
-
-  dependencies: TDependencies
-
-  labels?: Labels
-
-  monikers: CreatableProvider<TProvider>['monikers']
-
-  providerName: string
-
-  scope: ProviderFactoryScope
-
-  private _uniqueId: symbol
-
-  constructor(
-    creatableProvider: CreatableProvider<TProvider>,
-    dependencies: TDependencies,
-    params: Omit<TProvider['params'], 'context'>,
-    labels: Labels = {},
-    scope: ProviderFactoryScope = 'context',
-  ) {
-    this.creatableProvider = creatableProvider
-    this.defaultParams = params
-    this.defaultMoniker = creatableProvider.defaultMoniker
-    this.dependencies = dependencies
-    this.monikers = creatableProvider.monikers
-    this.scope = scope
-    assertEx(this.monikers.includes(this.defaultMoniker), () => 'defaultMoniker must be in monikers')
-    this.labels = Object.assign({}, (creatableProvider as WithOptionalLabels).labels ?? {}, labels ?? {})
-    this.providerName = creatableProvider.name
-    this._uniqueId = Symbol(providerFactoryDescription(this))
-  }
-
-  get resolvedMoniker() {
-    const labels: Labels = this.labels ?? {}
-    const labelString = Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(',')
-    return labelString.length === 0 ? `${this.defaultMoniker}` : `${this.defaultMoniker}|${labelString}`
-  }
-
-  get uniqueId(): symbol {
-    return this._uniqueId
-  }
-
-  static withParams<TInstance extends CreatableProviderInstance, TDependencies extends ProviderMoniker[]>(
-    creatableProvider: CreatableProvider<TInstance>,
-    dependencies: TDependencies,
-    params: Omit<TInstance['params'], 'context'>,
-    labels: Labels = {},
-  ) {
-    return new ProviderFactory<TInstance, TDependencies>(creatableProvider, dependencies, params, labels)
-  }
-
-  factory<TInstance extends CreatableProviderInstance, TDependencies extends ProviderMoniker[]>(
-    this: CreatableProviderFactory<TInstance, TDependencies>,
-    dependencies: TDependencies,
-    params: Omit<TInstance['params'], 'context'>,
-    labels: Labels = {},
-  ) {
-    return new ProviderFactory<TInstance, TDependencies>(this.creatableProvider, dependencies, params, labels)
-  }
-
-  async getInstance(this: CreatableProviderFactory<TProvider>, params: TProvider['params'], { start = true }: GetInstanceOptions): Promise<TProvider> {
-    let scopeObject: Record<string, unknown> = {}
-    switch (this.scope) {
-      case 'global': {
-        if (globalThis.xyoServiceSingletons === undefined) {
-          globalThis.xyoServiceSingletons = {}
-        }
-        scopeObject = globalThis.xyoServiceSingletons
-        break
-      }
-      case 'context': {
-        const context = assertEx(
-          params?.context,
-          () => 'Context is required for context-scoped providers',
-        )
-        if (context.singletons === undefined) {
-          context.singletons = {}
-        }
-        scopeObject = context.singletons
-        break
-      }
-      default: {
-        scopeObject = {}
-        break
-      }
-    }
-    const mergedParams: TProvider['params'] = {
-      ...this.defaultParams,
-      ...params,
-    } as TProvider['params']
-    const resultPromise = scopeObject[this.resolvedMoniker] as Promise<TProvider> ?? this.creatableProvider.create<TProvider>(mergedParams)
-    scopeObject[this.resolvedMoniker] = resultPromise
-    const result = await resultPromise
-    if (start) {
-      assertEx(await result.start(), () => `Failed to start provider instance [${this.resolvedMoniker}]`)
-    }
-    return result
-  }
-
-  async tryGetInstance(
-    this: CreatableProviderFactory<TProvider>,
-    params: TProvider['params'],
-    options?: GetInstanceOptions,
-  ): Promise<TProvider | undefined> {
-    try {
-      return await this.getInstance(params, options)
-    } catch {
-      return
-    }
-  }
-}

package/src/CreatableProvider/ProviderFactoryLocator.ts

@@ -1,170 +0,0 @@
-import { hasAllLabels, type Labels } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type { Provider, ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderContext } from '../model/index.ts'
-import type { CreatableProviderFactory, CreatableProviderInstance } from './CreatableProvider.ts'
-import { type CreatableProviderRegistry, registerCreatableProviderFactory } from './CreatableProviderRegistry.ts'
-import type { ProviderFactoryGetInstanceOptions } from './GetInstanceOptions.ts'
-import { hasLabels, type LabeledCreatableProviderFactory } from './LabeledCreatableProviderFactory.ts'
-import type { ProviderFactoryLocatorInstance } from './ProviderFactoryLocatorInstance.ts'
-
-/**
- * A class which encapsulates the Service Locator Pattern for Provider Factories
- */
-export class ProviderFactoryLocator<TContext extends CreatableProviderContext = CreatableProviderContext,
-  TMonikers extends ProviderMoniker[] = ProviderMoniker[]> implements ProviderFactoryLocatorInstance<TContext> {
-  protected readonly _context: TContext
-  protected readonly _registry: CreatableProviderRegistry<TMonikers>
-
-  private _frozen = false
-  private _parent?: ProviderFactoryLocatorInstance<TContext>
-  private _validateDepsOnRegister: boolean
-
-  constructor(context: (Omit<TContext, 'locator'> & { locator?: TContext['locator'] }), registry: CreatableProviderRegistry = {}, validateDepsOnRegister = false) {
-    this._registry = registry
-    this._context = { ...context, locator: this } as unknown as TContext
-    this._parent = context.locator as ProviderFactoryLocatorInstance<TContext>
-    this._validateDepsOnRegister = validateDepsOnRegister
-  }
-
-  get context() {
-    return this._context
-  }
-
-  get logger() {
-    return this.context.logger
-  }
-
-  /**
-   * The current registry for the module factory
-   */
-  get registry(): Readonly<CreatableProviderRegistry> {
-    return this._registry
-  }
-
-  protected get validateDepsOnRegister() {
-    return this._validateDepsOnRegister
-  }
-
-  freeze() {
-    this._frozen = true
-  }
-
-  async getInstance<TProvider extends Provider<ProviderMoniker>>(
-    moniker: TProvider['moniker'],
-    { start = true, labels }: ProviderFactoryGetInstanceOptions = {},
-  ) {
-    return assertEx(
-      await this.tryGetInstance<TProvider>(moniker, { start, labels }),
-      () => `No provider instance for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ''} could be created`,
-    )
-  }
-
-  has(moniker: TMonikers[number]): boolean {
-    return !!this._registry[moniker]
-  }
-
-  /**
-   * Locates a provider factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the provider
-   * @param labels The labels for the provider factory
-   * @returns A provider factory that matches the supplied moniker and labels or throws if one is not found
-   */
-  locate<TProvider extends Provider<ProviderMoniker>>(moniker: TProvider['moniker'], labels?: Labels):
-    CreatableProviderFactory<CreatableProviderInstance<TProvider>> | LabeledCreatableProviderFactory<CreatableProviderInstance<TProvider>> {
-    return assertEx(
-      this.tryLocate<TProvider>(moniker, labels),
-
-      () => `No module factory for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ''} registered`,
-    )
-  }
-
-  merge(locator: ProviderFactoryLocatorInstance): ProviderFactoryLocatorInstance {
-    const registry = { ...this.registry }
-    for (const moniker in locator.registry) {
-      if (registry[moniker]) {
-        registry[moniker].push(...(locator.registry[moniker] ?? []))
-      } else {
-        registry[moniker] = locator.registry[moniker]
-      }
-    }
-    return new ProviderFactoryLocator(this.context, registry)
-  }
-
-  /**
-   * Registers a single module factory (with optional tags) with the locator
-   * @param factory The factory to register
-   * @param labels The labels for the module factory
-   */
-  register(factory: CreatableProviderFactory, labels?: Labels, primary: boolean | ProviderMoniker | ProviderMoniker[] = false): this {
-    assertEx(!this._frozen, () => 'Cannot register a module factory after the locator has been frozen')
-    if (this.validateDepsOnRegister) {
-      const missingDeps = factory.dependencies.filter(dep => !this.registered(dep))
-      assertEx(missingDeps.length === 0, () => `Cannot register module factory [${factory.uniqueId.description}] due to missing dependencies: ${missingDeps.join(', ')}`)
-    }
-    registerCreatableProviderFactory(this._registry, factory, labels, primary)
-    return this
-  }
-
-  /**
-   * Registers multiple module factories with the locator
-   * @param factories The factories to register
-   */
-  registerMany(factories: CreatableProviderFactory[]): this {
-    for (const factory of factories) {
-      this.register(factory)
-    }
-    return this
-  }
-
-  registered(moniker: ProviderMoniker) {
-    return !!this.registry[moniker] || (this._parent?.registered(moniker) ?? false)
-  }
-
-  async tryGetInstance<TProvider extends Provider<ProviderMoniker>>(
-    moniker: TProvider['moniker'],
-    { start = true, labels }: ProviderFactoryGetInstanceOptions = {},
-  ) {
-    const resolvedParams = { context: this.context } as CreatableProviderInstance<TProvider>['params']
-    const factory = this.tryLocate<TProvider>(moniker, labels)
-    if (factory) {
-      if (this.context.singletons[factory.uniqueId]) {
-        return this.context.singletons[factory.uniqueId] as CreatableProviderInstance<TProvider>
-      }
-      this.logger?.info(`Creating provider instance for moniker [${moniker}]${labels ? ` with labels [${JSON.stringify(labels)}]` : ''} using factory [${factory.uniqueId.description}]`)
-      const result = await factory.getInstance(resolvedParams, { start })
-      this.context.singletons[factory.uniqueId] = result
-      return result
-    }
-  }
-
-  /**
-   * Tries to locate a module factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the module
-   * @param labels The labels for the module factory
-   * @returns A module factory that matches the supplied moniker and labels or undefined
-   */
-  tryLocate<TProvider extends Provider<ProviderMoniker>>(moniker: TProvider['moniker'], labels?: Labels) {
-    const result = (labels
-      // Find the first factory that has labels and has all the labels provided
-      ? (this._registry[moniker]?.filter(hasLabels).find(factory => hasAllLabels(factory?.labels, labels)) ?? this._registry[moniker]?.[0])
-      // Otherwise, return the first factory
-      : this._registry[moniker]?.[0]) ?? this._parent?.tryLocate<TProvider>(moniker, labels)
-
-    return result as CreatableProviderFactory<CreatableProviderInstance<TProvider>>
-      | LabeledCreatableProviderFactory<CreatableProviderInstance<TProvider>> | undefined
-  }
-
-  validateDependencies(recursive = false) {
-    if (recursive) {
-      this._parent?.validateDependencies()
-    }
-    for (const moniker in this.registry) {
-      for (const factory of this.registry[moniker] ?? []) {
-        const missingDeps = factory.dependencies.filter(dep => !this.registered(dep))
-        assertEx(missingDeps.length === 0, () => `Module factory [${factory.uniqueId.description}] is missing dependencies: ${missingDeps.join(', ')}`)
-      }
-    }
-  }
-}

package/src/CreatableProvider/ProviderFactoryLocatorInstance.ts

@@ -1,70 +0,0 @@
-import type { Labels } from '@xylabs/sdk-js'
-import type { Provider, ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderContext } from '../model/index.ts'
-import type { CreatableProviderFactory, CreatableProviderInstance } from './CreatableProvider.ts'
-import type { CreatableProviderRegistry } from './CreatableProviderRegistry.ts'
-import type { ProviderFactoryGetInstanceOptions } from './GetInstanceOptions.ts'
-import type { LabeledCreatableProviderFactory } from './LabeledCreatableProviderFactory.ts'
-
-/** Interface for ProviderFactoryLocator instances. */
-export interface ProviderFactoryLocatorInstance<T extends CreatableProviderContext = CreatableProviderContext> {
-
-  context: T
-
-  /**
-   * The current registry for the module factory
-   */
-  registry: Readonly<CreatableProviderRegistry>
-
-  freeze(): void
-
-  getInstance<TProvider extends Provider<ProviderMoniker>>(
-    moniker: TProvider['moniker'],
-    options?: ProviderFactoryGetInstanceOptions,
-  ): Promise<CreatableProviderInstance<TProvider>>
-
-  /**
-   * Locates a module factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the module
-   * @param labels The labels for the module factory
-   * @returns A module factory that matches the supplied moniker and labels or throws if one is not found
-   */
-  locate<TProvider extends Provider<ProviderMoniker>>(moniker: ProviderMoniker, labels?: Labels):
-    CreatableProviderFactory<CreatableProviderInstance<TProvider>> | LabeledCreatableProviderFactory<CreatableProviderInstance<TProvider>> | undefined
-
-  merge(locator: ProviderFactoryLocatorInstance): ProviderFactoryLocatorInstance
-
-  /**
-   * Registers a single module factory (with optional tags) with the locator
-   * @param factory The factory to register
-   * @param labels The labels for the module factory
-   */
-  register(factory: CreatableProviderFactory, labels?: Labels, primary?: boolean | ProviderMoniker | ProviderMoniker[]): ProviderFactoryLocatorInstance
-
-  /**
-   * Registers multiple module factories with the locator
-   * @param factories The factories to register
-   */
-  registerMany(factories: CreatableProviderFactory[]): ProviderFactoryLocatorInstance
-
-  registered(moniker: ProviderMoniker): boolean
-
-  tryGetInstance<TProvider extends Provider<ProviderMoniker>>(
-    moniker: TProvider['moniker'],
-    options?: ProviderFactoryGetInstanceOptions,
-  ): Promise<CreatableProviderInstance<TProvider> | undefined>
-
-  /**
-   * Tries to locate a module factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the module
-   * @param labels The labels for the module factory
-   * @returns A module factory that matches the supplied moniker and labels or undefined
-   */
-  tryLocate<TProvider extends Provider<ProviderMoniker>>(
-    moniker: ProviderMoniker,
-    labels?: Labels
-  ): CreatableProviderFactory<CreatableProviderInstance<TProvider>> | LabeledCreatableProviderFactory<CreatableProviderInstance<TProvider>> | undefined
-
-  validateDependencies(): void
-}

package/src/CreatableProvider/index.ts

@@ -1,8 +0,0 @@
-export * from './AbstractCreatableProvider.ts'
-export * from './CreatableProvider.ts'
-export * from './CreatableProviderRegistry.ts'
-export * from './GetInstanceOptions.ts'
-export * from './LabeledCreatableProviderFactory.ts'
-export * from './ProviderFactory.ts'
-export * from './ProviderFactoryLocator.ts'
-export * from './ProviderFactoryLocatorInstance.ts'

package/src/SignedBigInt.ts

@@ -1,59 +0,0 @@
-import {
-  type Hex,
-  hexToBigInt,
-  toHex,
-} from '@xylabs/sdk-js'
-import { isObject } from '@xylabs/sdk-js'
-
-/** Represents a negative bigint value stored as a hex string */
-export interface NegativeBigInt {
-  negative: Hex
-}
-
-/** Represents a positive bigint value stored as a hex string */
-export interface PositiveBigInt {
-  positive: Hex
-}
-
-/** A signed bigint value represented as either a negative or positive hex string */
-export type SignedBigInt = NegativeBigInt | PositiveBigInt
-
-/** Type guard that checks if a value is a NegativeBigInt */
-export const isNegativeBigInt = (value: unknown): value is NegativeBigInt => {
-  return isObject(value) && 'negative' in value && typeof value.negative === 'string'
-}
-
-/** Type guard that checks if a value is a PositiveBigInt */
-export const isPositiveBigInt = (value: unknown): value is PositiveBigInt => {
-  return isObject(value) && 'positive' in value && typeof value.positive === 'string'
-}
-
-/** parseSignedBigInt constant. */
-export const parseSignedBigInt = (value: SignedBigInt): bigint => {
-  if (isNegativeBigInt(value)) {
-    return -hexToBigInt(value.negative)
-  } else if (isPositiveBigInt(value)) {
-    return hexToBigInt(value.positive)
-  } else {
-    throw new Error('Invalid balance type')
-  }
-}
-
-/** toSignedBigInt constant. */
-export const toSignedBigInt = (value: bigint): SignedBigInt => {
-  return value < 0n ? { negative: toHex(-value) } : { positive: toHex(value) }
-}
-
-/** toPositiveBigInt constant. */
-export const toPositiveBigInt = (value: unknown): PositiveBigInt => {
-  if (isNegativeBigInt(value)) {
-    return { positive: toHex(0n) }
-  }
-  if (isPositiveBigInt(value)) {
-    return { positive: value.positive }
-  }
-  if (typeof value === 'bigint') {
-    return { positive: toHex(value) }
-  }
-  throw new Error('Invalid value for positive big int')
-}