lz4.ts

import type LZ4Namespace from 'lz4';

type LZ4Module = typeof LZ4Namespace;

// Loader function — extracted so tests can inject a stub without
// having to patch CJS-only Module._load. Default is the real require.
// eslint-disable-next-line global-require
let loader: () => LZ4Module = () => require('lz4');

/** Test-only: replace the loader. Restores the real one when called with no arg. */
export function setLz4LoaderForTest(fn?: () => LZ4Module): void {
  // eslint-disable-next-line global-require
  loader = fn ?? (() => require('lz4'));
}

function tryLoadLZ4Module(): LZ4Module | undefined {
  try {
    return loader();
  } catch (err) {
    if (!(err instanceof Error) || !('code' in err)) {
      // eslint-disable-next-line no-console
      console.warn('Unexpected error loading LZ4 module: Invalid error object', err);
      return undefined;
    }

    if (err.code === 'MODULE_NOT_FOUND') {
      return undefined;
    }

    if (err.code === 'ERR_DLOPEN_FAILED') {
      // eslint-disable-next-line no-console
      console.warn('LZ4 native module failed to load: Architecture or version mismatch', err);
      return undefined;
    }

    // If it's not a known error, return undefined
    // eslint-disable-next-line no-console
    console.warn('Unknown error loading LZ4 module: Unhandled error code', err);
    return undefined;
  }
}

// The null is already tried resolving that failed
let resolvedModule: LZ4Module | null | undefined;

function getResolvedModule() {
  if (resolvedModule === undefined) {
    resolvedModule = tryLoadLZ4Module() ?? null;
  }
  return resolvedModule === null ? undefined : resolvedModule;
}

/** Test-only: reset the memoized resolution so the next call re-invokes the loader. */
export function resetLz4CacheForTest(): void {
  resolvedModule = undefined;
}

export default getResolvedModule;