@linktr.ee/messaging-react 4.2.0-rc-1787325521 → 4.2.0-rc-1787325710

package/src/logging/index.test.tsx

@@ -1,136 +0,0 @@
-import type { Logger } from '@linktr.ee/messaging-core'
-import { render } from '@testing-library/react'
-import React from 'react'
-import { describe, it, expect, vi, afterEach } from 'vitest'
-
-import {
-  MessagingLoggerProvider,
-  consoleLogger,
-  resolveLogger,
-  useMessagingLogger,
-} from './index'
-
-const ERROR_MESSAGE = '[MessagingShell] Failed to load channels:'
-
-/** Logs one error through the seam the way a call site would. */
-const ErrorEmitter: React.FC<{ error: Error }> = ({ error }) => {
-  const logger = useMessagingLogger()
-  logger.error(ERROR_MESSAGE, error)
-  return null
-}
-
-/** Emits one line at every level so partial-sink fallback is observable. */
-const AllLevelsEmitter: React.FC = () => {
-  const logger = useMessagingLogger()
-  logger.debug('debug line', 1)
-  logger.info('info line', 2)
-  logger.warn('warn line', 3)
-  logger.error('error line', 4)
-  return null
-}
-
-afterEach(() => {
-  vi.restoreAllMocks()
-})
-
-describe('logger seam', () => {
-  it('routes error to an injected sink with the exact message and raw error object', () => {
-    const error = new Error('boom')
-    const sink = { error: vi.fn() }
-
-    render(
-      <MessagingLoggerProvider logger={sink}>
-        <ErrorEmitter error={error} />
-      </MessagingLoggerProvider>
-    )
-
-    expect(sink.error).toHaveBeenCalledTimes(1)
-    expect(sink.error).toHaveBeenCalledWith(ERROR_MESSAGE, error)
-    // The raw Error instance, not a serialized copy.
-    expect(sink.error.mock.calls[0][1]).toBe(error)
-  })
-
-  it('passes identical arguments to console.error when no sink is injected', () => {
-    const error = new Error('boom')
-    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
-    const sink = { error: vi.fn() }
-
-    render(
-      <MessagingLoggerProvider logger={sink}>
-        <ErrorEmitter error={error} />
-      </MessagingLoggerProvider>
-    )
-    const injectedArgs = sink.error.mock.calls[0]
-
-    // No provider at all, and a provider with no logger prop: both must produce
-    // byte-identical console output to what the injected sink received.
-    render(<ErrorEmitter error={error} />)
-    render(
-      <MessagingLoggerProvider>
-        <ErrorEmitter error={error} />
-      </MessagingLoggerProvider>
-    )
-
-    expect(consoleError).toHaveBeenCalledTimes(2)
-    expect(consoleError.mock.calls[0]).toEqual(injectedArgs)
-    expect(consoleError.mock.calls[1]).toEqual(injectedArgs)
-    expect(consoleError.mock.calls[0][1]).toBe(error)
-  })
-
-  it('falls back to console for the levels a partial sink omits', () => {
-    const consoleLog = vi.spyOn(console, 'log').mockImplementation(() => {})
-    const consoleWarn = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
-    const sink: Logger = { warn: vi.fn(), error: vi.fn() }
-
-    render(
-      <MessagingLoggerProvider logger={sink}>
-        <AllLevelsEmitter />
-      </MessagingLoggerProvider>
-    )
-
-    expect(sink.warn).toHaveBeenCalledWith('warn line', 3)
-    expect(sink.error).toHaveBeenCalledWith('error line', 4)
-    expect(consoleWarn).not.toHaveBeenCalled()
-    expect(consoleError).not.toHaveBeenCalled()
-    // debug and info are unset on the sink, so both land on console.log.
-    expect(consoleLog.mock.calls).toEqual([
-      ['debug line', 1],
-      ['info line', 2],
-    ])
-  })
-
-  it('defaults every level to console when the hook is used with no provider', () => {
-    const consoleLog = vi.spyOn(console, 'log').mockImplementation(() => {})
-    const consoleWarn = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
-
-    render(<AllLevelsEmitter />)
-
-    expect(consoleLog.mock.calls).toEqual([
-      ['debug line', 1],
-      ['info line', 2],
-    ])
-    expect(consoleWarn).toHaveBeenCalledWith('warn line', 3)
-    expect(consoleError).toHaveBeenCalledWith('error line', 4)
-  })
-
-  it('resolveLogger keeps provided levels and fills the rest from console', () => {
-    const warn = vi.fn()
-    const resolved = resolveLogger({ warn })
-
-    expect(resolved.warn).toBe(warn)
-    expect(resolved.debug).toBe(consoleLogger.debug)
-    expect(resolved.info).toBe(consoleLogger.info)
-    expect(resolved.error).toBe(consoleLogger.error)
-    expect(resolveLogger()).toEqual(consoleLogger)
-  })
-
-  it('consoleLogger dispatches through console at call time, not bind time', () => {
-    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
-
-    consoleLogger.error('late spy', 'arg')
-
-    expect(consoleError).toHaveBeenCalledWith('late spy', 'arg')
-  })
-})

package/src/logging/index.tsx

@@ -1,48 +0,0 @@
-import type { Logger } from '@linktr.ee/messaging-core'
-import React, { createContext, useContext, useMemo } from 'react'
-
-/**
- * Default sink: the console calls the package makes today. Wrappers, not
- * `console.error.bind(console)`, so a later-installed spy is still observed.
- */
-export const consoleLogger: Required<Logger> = {
-  debug: (message, ...args) => console.log(message, ...args),
-  info: (message, ...args) => console.log(message, ...args),
-  warn: (message, ...args) => console.warn(message, ...args),
-  error: (message, ...args) => console.error(message, ...args),
-}
-
-/**
- * Merge a partial sink over the console defaults, so a consumer can route only
- * the levels it cares about (e.g. `error`) and leave the rest on console.
- */
-export const resolveLogger = (logger?: Logger): Required<Logger> => ({
-  debug: logger?.debug ?? consoleLogger.debug,
-  info: logger?.info ?? consoleLogger.info,
-  warn: logger?.warn ?? consoleLogger.warn,
-  error: logger?.error ?? consoleLogger.error,
-})
-
-const LoggerContext = createContext<Required<Logger>>(consoleLogger)
-
-/**
- * Provides the resolved logger sink to the messaging subtree. Rendered by
- * `MessagingProvider`; usable standalone in tests or in a subtree that needs a
- * different sink.
- */
-export const MessagingLoggerProvider: React.FC<{
-  logger?: Logger
-  children: React.ReactNode
-}> = ({ logger, children }) => {
-  const value = useMemo(() => resolveLogger(logger), [logger])
-  return (
-    <LoggerContext.Provider value={value}>{children}</LoggerContext.Provider>
-  )
-}
-
-/**
- * The logger sink for the current subtree. Falls back to console when no
- * provider (or no `logger` prop) is present, so call sites never branch.
- */
-export const useMessagingLogger = (): Required<Logger> =>
-  useContext(LoggerContext)