@pfeiferio/message-resolver

Resolve messages deterministically based on structured selectors and ordered priorities.

@pfeiferio/message-resolver is a small utility for selecting the best matching message from a set of candidates using attribute-based selectors and an explicit priority order.

It is designed for applications that need predictable message resolution logic without introducing a full rule engine or i18n framework.

Features

• Attribute-based selectors (e.g. [type=email][scope=register])
• Deterministic priority resolution
• Fast selector matching using bit masks
• Optional placeholder replacement
• No side effects, no global state

Installation

npm install @pfeiferio/message-resolver

Basic usage

Define messages

const messages = {
  '[type=email]': {
    email: 'email error'
  },
  '[scope=register]': {
    email: 'register email error'
  }
}

Define priority order

const priorities = ['type', 'scope']

The order defines the relative priority of selector attributes. Attributes listed later have higher priority.

Create a resolver

import { MessageResolver } from '@pfeiferio/message-resolver'

const resolver = new MessageResolver(messages, priorities)

Resolving messages

const result = resolver.find(
  { type: 'email', scope: 'register' },
  'email'
)

console.log(result.message)
// → "register email error"

If no message matches, find() returns null.

If multiple selectors match, the resolver chooses the message with the highest priority based on the configured order.

Selector semantics

Selectors use a simple attribute syntax:

[type=email][scope=register]

A selector matches if all attributes are present in the identifier object.

selector.test({ type: 'email', scope: 'register' }) // true
selector.test({ type: 'email' })                    // false

Placeholder interpolation (optional)

@pfeiferio/message-resolver does not perform placeholder interpolation by itself.

If a resolved message contains placeholders, they can be interpolated explicitly using a separate library such as @pfeiferio/string-interpolate.

import { interpolate } from '@pfeiferio/string-interpolate'

const result = resolver.find({ type: 'email' }, 'email')
const message = interpolate(result.message, { type: 'email' })

Unresolved placeholders are left untouched.

What this package is not

• ❌ Not a message broker
• ❌ Not a logger
• ❌ Not an i18n framework
• ❌ Not a rule engine

This package focuses on deterministic message resolution only.

Mental model

Given a set of messages and a context, resolve exactly one message in a predictable way.

License

MIT