performance-helpers 1.0.0 → 1.0.1

package/test/powerLatch.branches.extra.test.js

@@ -1,115 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { PowerLatch } from '../src/helpers/powerLatch.js';
-
-describe('PowerLatch branches extra', () => {
-  it('decrementUnlessZero returns 0 when already zero', () => {
-    const l = new PowerLatch(0);
-    expect(l.decrementUnlessZero()).toBe(0);
-  });
-
-  it('countDown with zero returns without changing', () => {
-    const l = new PowerLatch(2);
-    expect(l.countDown(0)).toBe(2);
-  });
-
-  it('wait with timeout rejects with ETIMEOUT', async () => {
-    const l = new PowerLatch(1);
-    await expect(l.wait(5)).rejects.toHaveProperty('code', 'ETIMEOUT');
-  });
-
-  it('abort rejects waiters and calls onAbort', async () => {
-    const onAbort = jestFn();
-    const l = new PowerLatch(1, { onAbort });
-    const p = l.wait();
-    l.abort(new Error('fail'));
-    await expect(p).rejects.toBeTruthy();
-    expect(onAbort.called).toBe(true);
-  });
-
-  it('wait with signal rejects when signal aborted', async () => {
-    const l = new PowerLatch(1);
-    const ac = new AbortController();
-    const p = l.wait({ signal: ac.signal });
-    ac.abort();
-    await expect(p).rejects.toSatisfy((err) => {
-      if (!err) return false;
-      if (err && err.code === 'EABORT') return true;
-      if (err && (err.name === 'AbortError' || /abort/i.test(String(err.message)))) return true;
-      return false;
-    });
-  });
-
-  it('wait rejects immediately when provided signal is already aborted', async () => {
-    const l = new PowerLatch(1);
-    const ac = new AbortController();
-    ac.abort(new Error('already aborted'));
-
-    await expect(l.wait({ signal: ac.signal, timeout: 30 })).rejects.toSatisfy((err) => {
-      if (!err) return false;
-      if (err && (err.code === 'EABORT' || /abort/i.test(String(err.message)))) return true;
-      return false;
-    });
-  });
-
-  it('reset clears aborted state and resolves when count set to zero', async () => {
-    const l = new PowerLatch(1);
-    const p = l.wait();
-    l.abort(new Error('x'));
-    await expect(p).rejects.toBeTruthy();
-    // reset to zero should resolve new waiters
-    l.reset(0);
-    await expect(l.wait()).resolves.toBeUndefined();
-  });
-
-  it('wait rejects immediately after abort with default abort error and reset restores normal waiting', async () => {
-    const l = new PowerLatch(2);
-    l.abort();
-
-    await expect(l.wait()).rejects.toMatchObject({ code: 'EABORT' });
-
-    l.reset(1);
-    const waiter = l.wait();
-    l.countDown();
-    await expect(waiter).resolves.toBeUndefined();
-  });
-
-  it('removes abort listeners when a waiter resolves normally', async () => {
-    const addEventListener = vi.fn();
-    const removeEventListener = vi.fn();
-    const signal = {
-      aborted: false,
-      reason: undefined,
-      addEventListener,
-      removeEventListener,
-    };
-
-    const l = new PowerLatch(1);
-    const waiter = l.wait({ signal, timeout: 50 });
-    l.countDown();
-    await waiter;
-
-    expect(addEventListener).toHaveBeenCalledWith('abort', expect.any(Function), { once: true });
-    expect(removeEventListener).toHaveBeenCalledWith('abort', expect.any(Function));
-  });
-
-  it('swallows errors from onAbort callbacks', () => {
-    const l = new PowerLatch(1, {
-      onAbort() {
-        throw new Error('abort hook failed');
-      },
-    });
-
-    expect(() => l.abort(new Error('stop'))).not.toThrow();
-  });
-});
-
-// small helper to simulate jest-like spy without adding deps
-function jestFn() {
-  const fn = function (reason) {
-    fn.called = true;
-    fn.last = reason;
-  };
-  fn.called = false;
-  fn.last = undefined;
-  return fn;
-}

package/test/powerLatch.test.js

@@ -1,57 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { PowerLatch } from '../src/helpers/powerLatch.js';
-
-describe('PowerLatch', () => {
-  it('resolves wait when countDown called enough times', async () => {
-    const latch = new PowerLatch(2);
-    let done = false;
-    const p = latch.wait().then(() => {
-      done = true;
-    });
-    latch.countDown();
-    expect(done).toBe(false);
-    latch.countDown();
-    await p;
-    expect(done).toBe(true);
-  });
-
-  it('wait resolves immediately when count is zero', async () => {
-    const latch = new PowerLatch(0);
-    await expect(latch.wait()).resolves.toBeUndefined();
-  });
-
-  it('reset to zero resolves pending waiters', async () => {
-    const latch = new PowerLatch(2);
-    const p = latch.wait();
-    latch.reset(0);
-    await expect(p).resolves.toBeUndefined();
-  });
-
-  it('wait rejects on timeout', async () => {
-    const latch = new PowerLatch(1);
-    const p = latch.wait(10);
-    // do not count down
-    await expect(p).rejects.toHaveProperty('code', 'ETIMEOUT');
-  });
-
-  it('abort rejects pending waiters', async () => {
-    const latch = new PowerLatch(1);
-    const p = latch.wait();
-    latch.abort(new Error('bye'));
-    await expect(p).rejects.toThrow('bye');
-  });
-
-  it('static one factory works', async () => {
-    const l = PowerLatch.one();
-    expect(l.remaining).toBe(1);
-    l.countDown();
-    await expect(l.wait()).resolves.toBeUndefined();
-  });
-
-  it('decrementUnlessZero avoids negative', () => {
-    const l = new PowerLatch(0);
-    expect(l.decrementUnlessZero()).toBe(0);
-    const l2 = new PowerLatch(2);
-    expect(l2.decrementUnlessZero()).toBe(1);
-  });
-});

package/test/powerLogger.branches.test.js

@@ -1,98 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import * as PowerLoggerModule from '../src/helpers/powerLogger.js';
-
-const getCtor = (mod) => {
-  if (typeof mod === 'function') return mod;
-  if (mod && typeof mod.default === 'function') return mod.default;
-  if (mod && typeof mod.PowerLogger === 'function') return mod.PowerLogger;
-  throw new Error('PowerLogger constructor not found');
-};
-
-describe('PowerLogger branch coverage', () => {
-  it('does not expose legacy global helpers', () => {
-    const Ctor = getCtor(PowerLoggerModule);
-    const logger = new Ctor(0);
-    expect(typeof logger.hasLegacyDebug).toBe('undefined');
-    expect(typeof logger.syncLegacyCounter).toBe('undefined');
-  });
-
-  it('debug helpers accept function args (lazy evaluation)', () => {
-    const Ctor = getCtor(PowerLoggerModule);
-    const logger = new Ctor(0);
-    const side = { called: false };
-    const fn = () => {
-      side.called = true;
-      return 'ok';
-    };
-    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    logger.setDebugLevel(1);
-    logger.error(fn);
-    expect(side.called).toBe(true);
-    spy.mockRestore();
-  });
-
-  it('setDebugLevel handles thrown-toString gracefully', () => {
-    const Ctor = getCtor(PowerLoggerModule);
-    const logger = new Ctor(0);
-    // craft an object that throws when coerced
-    const bad = {
-      toString() {
-        throw new Error('bad');
-      },
-    };
-    logger.setDebugLevel(bad);
-    expect(logger.getDebugLevel()).toBe(0);
-  });
-
-  it('debug methods swallow exceptions thrown by lazy args and handle missing console methods', () => {
-    const Ctor = getCtor(PowerLoggerModule);
-    const logger = new Ctor(3);
-
-    // lazy arg that throws should be swallowed
-    const badFn = () => {
-      throw new Error('boom');
-    };
-    // spy console methods so we don't clutter output
-    const spyErr = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const spyWarn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const spyInfo = vi.spyOn(console, 'info').mockImplementation(() => {});
-    const spyLog = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    expect(() => logger.error(badFn)).not.toThrow();
-    expect(() => logger.warn(badFn)).not.toThrow();
-    expect(() => logger.info(badFn)).not.toThrow();
-    expect(() => logger.log(badFn)).not.toThrow();
-
-    spyErr.mockRestore();
-    spyWarn.mockRestore();
-    spyInfo.mockRestore();
-    spyLog.mockRestore();
-
-    // simulate missing console method (warn) - should simply return
-    const origWarn = console.warn;
-    try {
-      // @ts-ignore
-      console.warn = undefined;
-      expect(() => logger.warn('x')).not.toThrow();
-    } finally {
-      console.warn = origWarn;
-    }
-  });
-
-  it('setDebugLevel coerces boxed primitives and incrementCounter ignores empty names when disabled', () => {
-    const Ctor = getCtor(PowerLoggerModule);
-    const logger = new Ctor(0);
-
-    logger.setDebugLevel(new String('3'));
-    expect(logger.getDebugLevel()).toBe(3);
-
-    logger.setDebugLevel(new Boolean(false));
-    expect(logger.getDebugLevel()).toBe(0);
-
-    logger.incrementCounter('ignored');
-    logger.setDebugLevel(3);
-    logger.incrementCounter('');
-    logger.incrementCounter(null);
-    expect(logger.getDebugCounters()).toEqual({});
-  });
-});

package/test/powerLogger.formatter.name.test.js

@@ -1,58 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { PowerLogger } from '../src/helpers/powerLogger.js';
-
-describe('PowerLogger formatter and name option', () => {
-  it('includes name in JSON payload when provided', () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    try {
-      const logger = new PowerLogger(3, { format: 'json', name: 'my-logger' });
-      logger.log('hello');
-      expect(logSpy).toHaveBeenCalled();
-      const parsed = JSON.parse(logSpy.mock.calls[0][0]);
-      expect(parsed.level).toBe('log');
-      expect(parsed.name).toBe('my-logger');
-      expect(parsed.msg).toBe('hello');
-    } finally {
-      logSpy.mockRestore();
-    }
-  });
-
-  it('calls formatter when provided and uses its return value as payload', () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    try {
-      const formatter = (payload) => ({
-        l: payload.level,
-        n: payload.name || null,
-        m: payload.msg,
-      });
-      const logger = new PowerLogger(3, { format: 'json', name: 'x', formatter });
-      const infoSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
-      try {
-        logger.info('y');
-        expect(infoSpy).toHaveBeenCalled();
-        const parsed = JSON.parse(infoSpy.mock.calls[0][0]);
-        expect(parsed.l).toBe('info');
-        expect(parsed.n).toBe('x');
-        expect(parsed.m).toBe('y');
-      } finally {
-        infoSpy.mockRestore();
-      }
-    } finally {
-      logSpy.mockRestore();
-    }
-  });
-
-  it('allows formatter to return a string directly', () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    try {
-      const formatter = (payload) => `${payload.level}:${payload.msg}`;
-      const logger = new PowerLogger(3, { format: 'json', name: 'x', formatter });
-      logger.log('z');
-      expect(logSpy).toHaveBeenCalled();
-      const emitted = logSpy.mock.calls[0][0];
-      expect(emitted).toBe('log:z');
-    } finally {
-      logSpy.mockRestore();
-    }
-  });
-});

package/test/powerLogger.json.test.js

@@ -1,88 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { PowerLogger } from '../src/helpers/powerLogger.js';
-
-describe('PowerLogger JSON output mode', () => {
-  it('emits JSON on error/warn/info/log when format=json', () => {
-    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const infoSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    try {
-      const logger = new PowerLogger(3, { format: 'json' });
-      logger.error('err-msg');
-      logger.warn({ a: 1 });
-      logger.info(() => 'info-msg');
-      logger.log('one', 'two');
-
-      expect(errSpy).toHaveBeenCalled();
-      expect(warnSpy).toHaveBeenCalled();
-      expect(infoSpy).toHaveBeenCalled();
-      expect(logSpy).toHaveBeenCalled();
-
-      const parsed = JSON.parse(errSpy.mock.calls[0][0]);
-      expect(parsed.level).toBe('error');
-      expect(parsed.msg).toBe('err-msg');
-      expect(typeof parsed.ts).toBe('number');
-
-      const parsedWarn = JSON.parse(warnSpy.mock.calls[0][0]);
-      expect(parsedWarn.level).toBe('warn');
-      expect(parsedWarn.msg).toEqual({ a: 1 });
-
-      const parsedInfo = JSON.parse(infoSpy.mock.calls[0][0]);
-      expect(parsedInfo.level).toBe('info');
-      expect(parsedInfo.msg).toBe('info-msg');
-
-      const parsedLog = JSON.parse(logSpy.mock.calls[0][0]);
-      expect(parsedLog.level).toBe('log');
-      expect(Array.isArray(parsedLog.msg)).toBe(true);
-      expect(parsedLog.msg).toEqual(['one', 'two']);
-    } finally {
-      errSpy.mockRestore();
-      warnSpy.mockRestore();
-      infoSpy.mockRestore();
-      logSpy.mockRestore();
-    }
-  });
-
-  it('falls back to plain console arguments when JSON serialization fails', () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    try {
-      const circular = {};
-      circular.self = circular;
-      const logger = new PowerLogger(3, { format: 'json' });
-
-      logger.log(circular, 'tail');
-
-      expect(logSpy).toHaveBeenCalled();
-      // When JSON serialization contains circular references we now
-      // emit a safe JSON string (circulars replaced) instead of passing
-      // original args to the console. Verify the emitted JSON contains
-      // the safe representation and preserves additional args.
-      const out = logSpy.mock.calls[0][0];
-      const parsed = JSON.parse(out);
-      expect(parsed.level).toBe('log');
-      expect(parsed.msg[0]).toEqual({ self: '[Circular]' });
-      expect(parsed.msg[1]).toBe('tail');
-    } finally {
-      logSpy.mockRestore();
-    }
-  });
-
-  it('normalizes error-like payloads in error()', () => {
-    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    try {
-      const logger = new PowerLogger(1, { format: 'json' });
-      logger.error({ error: true, code: 'E_TEST', message: 'broken' });
-
-      expect(errSpy).toHaveBeenCalled();
-      const parsed = JSON.parse(errSpy.mock.calls[0][0]);
-      expect(parsed.level).toBe('error');
-      expect(parsed.msg).toBe('E_TEST: broken');
-    } finally {
-      errSpy.mockRestore();
-    }
-  });
-});

package/test/powerLogger.output.test.js

@@ -1,81 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { PowerLogger } from '../src/helpers/powerLogger.js';
-
-describe('PowerLogger output transport', () => {
-  it('calls provided output(payload) instead of console', () => {
-    const out = vi.fn();
-    const logger = new PowerLogger(3, { format: 'json', name: 't1', output: out });
-    logger.info('hello', { a: 1 });
-    expect(out).toHaveBeenCalled();
-    const payload = out.mock.calls[0][0];
-    expect(payload).toHaveProperty('level', 'info');
-    expect(payload).toHaveProperty('msg');
-    expect(payload).toHaveProperty('ts');
-    expect(payload).toHaveProperty('name', 't1');
-    expect(payload).toHaveProperty('format', 'json');
-  });
-
-  it('formatter can modify payload passed to output', () => {
-    const out = vi.fn();
-    const logger = new PowerLogger(3, {
-      format: 'json',
-      name: 't2',
-      output: out,
-      formatter: (p) => ({ lvl: p.level, m: p.msg, t: p.ts, nm: p.name }),
-    });
-
-    logger.error('oops');
-    expect(out).toHaveBeenCalled();
-    const payload = out.mock.calls[0][0];
-    expect(payload).toHaveProperty('lvl', 'error');
-    expect(payload).toHaveProperty('m');
-    expect(payload).toHaveProperty('t');
-    expect(payload).toHaveProperty('nm', 't2');
-  });
-
-  it('swallows output transport errors', () => {
-    const logger = new PowerLogger(3, {
-      format: 'json',
-      output() {
-        throw new Error('transport failed');
-      },
-    });
-
-    expect(() => logger.info('safe')).not.toThrow();
-  });
-
-  it('falls back to the original payload when formatter throws', () => {
-    const out = vi.fn();
-    const logger = new PowerLogger(3, {
-      format: 'json',
-      name: 'fallback',
-      output: out,
-      formatter() {
-        throw new Error('formatter failed');
-      },
-    });
-
-    logger.warn('hello');
-
-    expect(out).toHaveBeenCalled();
-    expect(out.mock.calls[0][0]).toMatchObject({
-      level: 'warn',
-      msg: 'hello',
-      format: 'json',
-      name: 'fallback',
-    });
-  });
-
-  it('passes formatter strings directly to output transports', () => {
-    const out = vi.fn();
-    const logger = new PowerLogger(3, {
-      format: 'json',
-      output: out,
-      formatter: (payload) => `${payload.level}:${payload.msg}`,
-    });
-
-    logger.info('transport-string');
-
-    expect(out).toHaveBeenCalledWith('info:transport-string');
-  });
-});

package/test/powerLogger.table.debug.test.js

@@ -1,77 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { PowerLogger } from '../src/helpers/powerLogger.js';
-
-describe('PowerLogger table and debug methods', () => {
-  it('calls console.debug when debug() invoked and level>=3', () => {
-    const debugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
-    try {
-      const logger = new PowerLogger(3);
-      logger.debug('x', 1);
-      expect(debugSpy).toHaveBeenCalled();
-      const callArgs = debugSpy.mock.calls[0];
-      expect(callArgs[0]).toBe('x');
-      expect(callArgs[1]).toBe(1);
-    } finally {
-      debugSpy.mockRestore();
-    }
-  });
-
-  it('emits JSON for debug() when format=json', () => {
-    const debugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
-    try {
-      const logger = new PowerLogger(3, { format: 'json' });
-      logger.debug({ a: 1 });
-      expect(debugSpy).toHaveBeenCalled();
-      const parsed = JSON.parse(debugSpy.mock.calls[0][0]);
-      expect(parsed.level).toBe('debug');
-      expect(parsed.msg).toEqual({ a: 1 });
-      expect(typeof parsed.ts).toBe('number');
-    } finally {
-      debugSpy.mockRestore();
-    }
-  });
-
-  it('uses console.table when available for table()', () => {
-    const tableSpy = vi.spyOn(console, 'table').mockImplementation(() => {});
-    try {
-      const logger = new PowerLogger(3);
-      const data = [{ a: 1 }, { a: 2 }];
-      logger.table(data);
-      expect(tableSpy).toHaveBeenCalled();
-      expect(tableSpy.mock.calls[0][0]).toBe(data);
-    } finally {
-      tableSpy.mockRestore();
-    }
-  });
-
-  it('emits JSON for table() when format=json', () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    try {
-      const logger = new PowerLogger(3, { format: 'json' });
-      const data = [{ a: 1 }, { a: 2 }];
-      logger.table(data);
-      expect(logSpy).toHaveBeenCalled();
-      const parsed = JSON.parse(logSpy.mock.calls[0][0]);
-      expect(parsed.level).toBe('table');
-      expect(Array.isArray(parsed.msg)).toBe(true);
-      expect(parsed.msg[0]).toEqual(data);
-    } finally {
-      logSpy.mockRestore();
-    }
-  });
-
-  it('falls back to console.log when console.table is unavailable', () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const originalTable = console.table;
-    try {
-      // @ts-ignore
-      console.table = undefined;
-      const logger = new PowerLogger(3);
-      logger.table('fallback-table');
-      expect(logSpy).toHaveBeenCalledWith('fallback-table');
-    } finally {
-      console.table = originalTable;
-      logSpy.mockRestore();
-    }
-  });
-});

package/test/powerLogger.test.js

@@ -1,59 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as PowerLoggerModule from '../src/helpers/powerLogger.js';
-
-const getCtor = (mod) => {
-  if (typeof mod === 'function') return mod;
-  if (mod && typeof mod.default === 'function') return mod.default;
-  if (mod && typeof mod.PowerLogger === 'function') return mod.PowerLogger;
-  throw new Error('PowerLogger constructor not found');
-};
-
-describe('PowerLogger', () => {
-  let logger;
-  beforeEach(() => {
-    const Ctor = getCtor(PowerLoggerModule);
-    logger = new Ctor(0);
-  });
-  afterEach(() => {
-    // nothing for now
-  });
-
-  it('sets and gets debug level', () => {
-    logger.setDebugLevel(2);
-    expect(logger.getDebugLevel()).toBe(2);
-    expect(logger.isDebugLevel(1)).toBe(true);
-    expect(logger.isDebugLevel(3)).toBe(false);
-  });
-
-  it('logs only when level permits', () => {
-    const spyError = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const spyWarn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const spyInfo = vi.spyOn(console, 'info').mockImplementation(() => {});
-    const spyLog = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    logger.setDebugLevel(1);
-    logger.error('e');
-    logger.warn('w');
-    expect(spyError).toHaveBeenCalled();
-    expect(spyWarn).not.toHaveBeenCalled();
-
-    logger.setDebugLevel(3);
-    logger.info('i');
-    logger.log('l');
-    expect(spyInfo).toHaveBeenCalled();
-    expect(spyLog).toHaveBeenCalled();
-
-    spyError.mockRestore();
-    spyWarn.mockRestore();
-    spyInfo.mockRestore();
-    spyLog.mockRestore();
-  });
-
-  it('increments counters when debug enabled', () => {
-    logger.setDebugLevel(3);
-    logger.incrementCounter('x');
-    expect(logger.getDebugCounters()).toEqual({ x: 1 });
-    logger.resetDebugCounters();
-    expect(logger.getDebugCounters()).toEqual({});
-  });
-});