@ocavue/utils 1.2.0 → 1.3.0

package/src/default-map.test.ts

@@ -2,7 +2,7 @@
 
 import { describe, it, expect } from 'vitest'
 
-import { DefaultMap } from './default-map'
+import { Counter, DefaultMap, DefaultWeakMap, WeakCounter } from './default-map'
 
 describe('DefaultMap', () => {
   it('creates default values for missing keys', () => {
@@ -184,3 +184,292 @@ describe('DefaultMap', () => {
     expect(map.get('group2').get('item1')).toBe(0)
   })
 })
+
+describe('DefaultWeakMap', () => {
+  it('creates default values for missing keys', () => {
+    const map = new DefaultWeakMap<object, number>(() => 0)
+    const key1 = {}
+    const key2 = {}
+
+    expect(map.get(key1)).toBe(0)
+    expect(map.get(key2)).toBe(0)
+  })
+
+  it('returns existing values for set keys', () => {
+    const map = new DefaultWeakMap<object, number>(() => 0)
+    const key = {}
+
+    map.set(key, 42)
+    expect(map.get(key)).toBe(42)
+  })
+
+  it('stores the default value when accessing missing key', () => {
+    const map = new DefaultWeakMap<object, number>(() => 5)
+    const key = {}
+
+    const value = map.get(key)
+    expect(value).toBe(5)
+    expect(map.has(key)).toBe(true)
+    expect(map.get(key)).toBe(5)
+  })
+
+  it('works with array factory', () => {
+    const map = new DefaultWeakMap<object, string[]>(() => [])
+    const key1 = {}
+    const key2 = {}
+
+    map.get(key1).push('item1')
+    map.get(key1).push('item2')
+    map.get(key2).push('item3')
+
+    expect(map.get(key1)).toEqual(['item1', 'item2'])
+    expect(map.get(key2)).toEqual(['item3'])
+  })
+
+  it('accepts initial entries', () => {
+    const key1 = {}
+    const key2 = {}
+    const key3 = {}
+    const initialEntries: [object, number][] = [
+      [key1, 1],
+      [key2, 2],
+      [key3, 3],
+    ]
+    const map = new DefaultWeakMap<object, number>(() => 0, initialEntries)
+
+    expect(map.get(key1)).toBe(1)
+    expect(map.get(key2)).toBe(2)
+    expect(map.get(key3)).toBe(3)
+
+    const key4 = {}
+    expect(map.get(key4)).toBe(0)
+  })
+
+  it('calls factory function only when key is missing', () => {
+    let callCount = 0
+    const map = new DefaultWeakMap<object, number>(() => {
+      callCount++
+      return 42
+    })
+    const existing = {}
+    const newKey = {}
+
+    map.set(existing, 100)
+
+    map.get(existing)
+    expect(callCount).toBe(0)
+
+    map.get(newKey)
+    expect(callCount).toBe(1)
+
+    map.get(newKey)
+    expect(callCount).toBe(1)
+  })
+
+  it('works with delete method', () => {
+    const map = new DefaultWeakMap<object, number>(() => 10)
+    const key = {}
+
+    map.get(key)
+    expect(map.has(key)).toBe(true)
+
+    map.delete(key)
+    expect(map.has(key)).toBe(false)
+
+    const value = map.get(key)
+    expect(value).toBe(10)
+    expect(map.has(key)).toBe(true)
+  })
+})
+
+describe('Counter', () => {
+  it('initializes counts to 0', () => {
+    const counter = new Counter<string>()
+
+    expect(counter.get('key1')).toBe(0)
+    expect(counter.get('key2')).toBe(0)
+  })
+
+  it('increments counts', () => {
+    const counter = new Counter<string>()
+
+    counter.increment('key1')
+    expect(counter.get('key1')).toBe(1)
+
+    counter.increment('key1')
+    expect(counter.get('key1')).toBe(2)
+
+    counter.increment('key2')
+    expect(counter.get('key2')).toBe(1)
+  })
+
+  it('increments by custom amounts', () => {
+    const counter = new Counter<string>()
+
+    counter.increment('key1', 5)
+    expect(counter.get('key1')).toBe(5)
+
+    counter.increment('key1', 3)
+    expect(counter.get('key1')).toBe(8)
+  })
+
+  it('decrements counts', () => {
+    const counter = new Counter<string>()
+
+    counter.set('key1', 10)
+    counter.decrement('key1')
+    expect(counter.get('key1')).toBe(9)
+
+    counter.decrement('key1')
+    expect(counter.get('key1')).toBe(8)
+  })
+
+  it('decrements by custom amounts', () => {
+    const counter = new Counter<string>()
+
+    counter.set('key1', 10)
+    counter.decrement('key1', 3)
+    expect(counter.get('key1')).toBe(7)
+
+    counter.decrement('key1', 2)
+    expect(counter.get('key1')).toBe(5)
+  })
+
+  it('allows negative counts', () => {
+    const counter = new Counter<string>()
+
+    counter.decrement('key1')
+    expect(counter.get('key1')).toBe(-1)
+
+    counter.decrement('key1', 5)
+    expect(counter.get('key1')).toBe(-6)
+  })
+
+  it('accepts initial entries', () => {
+    const initialEntries: [string, number][] = [
+      ['a', 5],
+      ['b', 10],
+      ['c', 15],
+    ]
+    const counter = new Counter<string>(initialEntries)
+
+    expect(counter.get('a')).toBe(5)
+    expect(counter.get('b')).toBe(10)
+    expect(counter.get('c')).toBe(15)
+    expect(counter.get('d')).toBe(0)
+  })
+
+  it('works with all Map methods', () => {
+    const counter = new Counter<string>()
+
+    counter.increment('key1')
+    counter.increment('key2', 2)
+
+    expect(counter.size).toBe(2)
+    expect(counter.has('key1')).toBe(true)
+    expect([...counter.keys()]).toEqual(['key1', 'key2'])
+    expect([...counter.values()]).toEqual([1, 2])
+  })
+})
+
+describe('WeakCounter', () => {
+  it('initializes counts to 0', () => {
+    const counter = new WeakCounter<object>()
+    const key1 = {}
+    const key2 = {}
+
+    expect(counter.get(key1)).toBe(0)
+    expect(counter.get(key2)).toBe(0)
+  })
+
+  it('increments counts', () => {
+    const counter = new WeakCounter<object>()
+    const key = {}
+
+    counter.increment(key)
+    expect(counter.get(key)).toBe(1)
+
+    counter.increment(key)
+    expect(counter.get(key)).toBe(2)
+  })
+
+  it('increments by custom amounts', () => {
+    const counter = new WeakCounter<object>()
+    const key = {}
+
+    counter.increment(key, 5)
+    expect(counter.get(key)).toBe(5)
+
+    counter.increment(key, 3)
+    expect(counter.get(key)).toBe(8)
+  })
+
+  it('decrements counts', () => {
+    const counter = new WeakCounter<object>()
+    const key = {}
+
+    counter.set(key, 10)
+    counter.decrement(key)
+    expect(counter.get(key)).toBe(9)
+
+    counter.decrement(key)
+    expect(counter.get(key)).toBe(8)
+  })
+
+  it('decrements by custom amounts', () => {
+    const counter = new WeakCounter<object>()
+    const key = {}
+
+    counter.set(key, 10)
+    counter.decrement(key, 3)
+    expect(counter.get(key)).toBe(7)
+
+    counter.decrement(key, 2)
+    expect(counter.get(key)).toBe(5)
+  })
+
+  it('allows negative counts', () => {
+    const counter = new WeakCounter<object>()
+    const key = {}
+
+    counter.decrement(key)
+    expect(counter.get(key)).toBe(-1)
+
+    counter.decrement(key, 5)
+    expect(counter.get(key)).toBe(-6)
+  })
+
+  it('accepts initial entries', () => {
+    const key1 = {}
+    const key2 = {}
+    const key3 = {}
+    const initialEntries: [object, number][] = [
+      [key1, 5],
+      [key2, 10],
+      [key3, 15],
+    ]
+    const counter = new WeakCounter<object>(initialEntries)
+
+    expect(counter.get(key1)).toBe(5)
+    expect(counter.get(key2)).toBe(10)
+    expect(counter.get(key3)).toBe(15)
+
+    const key4 = {}
+    expect(counter.get(key4)).toBe(0)
+  })
+
+  it('works with WeakMap methods', () => {
+    const counter = new WeakCounter<object>()
+    const key1 = {}
+    const key2 = {}
+
+    counter.increment(key1)
+    counter.increment(key2, 2)
+
+    expect(counter.has(key1)).toBe(true)
+    expect(counter.has(key2)).toBe(true)
+
+    counter.delete(key1)
+    expect(counter.has(key1)).toBe(false)
+  })
+})

package/src/default-map.ts

@@ -20,3 +20,79 @@ export class DefaultMap<K, V> extends Map<K, V> {
     return value
   }
 }
+
+/**
+ * A weak map that automatically creates values for missing keys using a factory function.
+ *
+ * Similar to DefaultMap but uses WeakMap as the base, allowing garbage collection of keys.
+ */
+export class DefaultWeakMap<K extends WeakKey, V> extends WeakMap<K, V> {
+  private readonly defaultFactory: () => V
+
+  constructor(
+    defaultFactory: () => V,
+    entries?: readonly (readonly [K, V])[] | null,
+  ) {
+    super(entries)
+    this.defaultFactory = defaultFactory
+  }
+
+  override get(key: K): V {
+    if (this.has(key)) {
+      return super.get(key)!
+    }
+    const value = this.defaultFactory()
+    this.set(key, value)
+    return value
+  }
+}
+
+/**
+ * A map that counts occurrences of keys.
+ *
+ * Similar to Python's [Counter](https://docs.python.org/3.13/library/collections.html#collections.Counter).
+ */
+export class Counter<K> extends DefaultMap<K, number> {
+  constructor(iterable?: Iterable<readonly [K, number]>) {
+    super(() => 0, iterable)
+  }
+
+  /**
+   * Increments the count for a key by a given amount (default 1).
+   */
+  increment(key: K, amount = 1): void {
+    this.set(key, this.get(key) + amount)
+  }
+
+  /**
+   * Decrements the count for a key by a given amount (default 1).
+   */
+  decrement(key: K, amount = 1): void {
+    this.set(key, this.get(key) - amount)
+  }
+}
+
+/**
+ * A weak map that counts occurrences of object keys.
+ *
+ * Similar to Counter but uses WeakMap as the base, allowing garbage collection of keys.
+ */
+export class WeakCounter<K extends WeakKey> extends DefaultWeakMap<K, number> {
+  constructor(entries?: readonly (readonly [K, number])[] | null) {
+    super(() => 0, entries)
+  }
+
+  /**
+   * Increments the count for a key by a given amount (default 1).
+   */
+  increment(key: K, amount = 1): void {
+    this.set(key, this.get(key) + amount)
+  }
+
+  /**
+   * Decrements the count for a key by a given amount (default 1).
+   */
+  decrement(key: K, amount = 1): void {
+    this.set(key, this.get(key) - amount)
+  }
+}

package/src/e2e.test.ts

@@ -0,0 +1,36 @@
+// @vitest-environment node
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { x } from 'tinyexec'
+import { glob } from 'tinyglobby'
+import { describe, it, expect, beforeAll } from 'vitest'
+
+const ROOT_DIR = path.join(import.meta.dirname, '..')
+const E2E_OUT_DIR = path.join(ROOT_DIR, 'e2e', 'dist')
+
+describe('e2e', () => {
+  beforeAll(async () => {
+    await x('pnpm', ['-w', 'build'], {
+      nodeOptions: { cwd: ROOT_DIR, stdio: 'inherit' },
+      throwOnError: true,
+    })
+    await x('pnpm', ['--filter', 'e2e', 'run', 'build'], {
+      nodeOptions: { cwd: ROOT_DIR, stdio: 'inherit' },
+      throwOnError: true,
+    })
+  })
+
+  it('bundler outputs match snapshot', async () => {
+    const files = await glob('**/*', { cwd: E2E_OUT_DIR, onlyFiles: true })
+    const output = ['']
+
+    for (const file of files.sort()) {
+      const content = fs.readFileSync(path.join(E2E_OUT_DIR, file), 'utf-8')
+      output.push('#'.repeat(80), file, '-'.repeat(80), content, '')
+    }
+
+    expect(output.join('\n')).toMatchSnapshot()
+  })
+})

package/src/get-id.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest'
 
-import { getId } from './get-id'
+import { getId, setMaxSafeInteger } from './get-id'
 
 describe('getId', () => {
   it('returns a positive number', () => {
@@ -11,4 +11,23 @@ describe('getId', () => {
   it('returns different values on consecutive calls', () => {
     expect(getId()).not.toBe(getId())
   })
+
+  it('never exceeds the configured maximum', () => {
+    const max = 5
+    setMaxSafeInteger(max)
+    let prevId = -1
+
+    try {
+      for (let i = 0; i < max * 3; i += 1) {
+        const id = getId()
+        expect(id).toBeLessThan(max)
+        expect(id).toBeGreaterThanOrEqual(1)
+        expect(id).not.toBe(prevId)
+
+        prevId = id
+      }
+    } finally {
+      setMaxSafeInteger(Number.MAX_SAFE_INTEGER)
+    }
+  })
 })

package/src/get-id.ts

@@ -1,9 +1,23 @@
 let id = 0
 
+let maxSafeInteger = Number.MAX_SAFE_INTEGER
+
+/**
+ * Sets the maximum safe integer for the id generator. Only for testing purposes.
+ *
+ * @internal
+ */
+export function setMaxSafeInteger(max: number) {
+  maxSafeInteger = max
+}
+
 /**
  * Generates a unique positive integer.
  */
 export function getId(): number {
-  id = (id % Number.MAX_SAFE_INTEGER) + 1
+  id++
+  if (id >= maxSafeInteger) {
+    id = 1
+  }
   return id
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 export * from './checker'
-export { DefaultMap } from './default-map'
+export { Counter, DefaultMap, DefaultWeakMap, WeakCounter } from './default-map'
 export * from './dom'
 export { formatBytes } from './format-bytes'
 export { getId } from './get-id'

package/src/map-group-by.ts

@@ -30,6 +30,8 @@ export function mapGroupByNative<K, T>(
   return Map.groupBy(items, keySelector)
 }
 
+const hasMapGroupBy: boolean = /* @__PURE__ */ (() => !!Map.groupBy)()
+
 /**
  * A polyfill for the `Map.groupBy` static method.
  *
@@ -38,4 +40,4 @@ export function mapGroupByNative<K, T>(
 export const mapGroupBy: <K, T>(
   items: Iterable<T>,
   keySelector: (item: T, index: number) => K,
-) => Map<K, T[]> = !!Map.groupBy ? mapGroupByNative : mapGroupByPolyfill
+) => Map<K, T[]> = hasMapGroupBy ? mapGroupByNative : mapGroupByPolyfill

package/src/object-group-by.ts

@@ -30,6 +30,8 @@ export function objectGroupByNative<K extends PropertyKey, T>(
   return Object.groupBy(items, keySelector)
 }
 
+const hasObjectGroupBy: boolean = /* @__PURE__ */ (() => !!Object.groupBy)()
+
 /**
  * A polyfill for the `Object.groupBy` static method.
  *
@@ -38,6 +40,6 @@ export function objectGroupByNative<K extends PropertyKey, T>(
 export const objectGroupBy: <K extends PropertyKey, T>(
   items: Iterable<T>,
   keySelector: (item: T, index: number) => K,
-) => Partial<Record<K, T[]>> = !!Object.groupBy
+) => Partial<Record<K, T[]>> = hasObjectGroupBy
   ? objectGroupByNative
   : objectGroupByPolyfill

package/src/once-stub-1.ts

@@ -0,0 +1,13 @@
+import { once } from './once'
+
+function fn1() {
+  console.log('fn1')
+}
+
+const once1 = once(fn1)
+
+function fn2() {
+  console.log('fn2')
+}
+
+export { once1, fn2 }

package/src/once-stub-2.ts

@@ -0,0 +1,3 @@
+import { fn2 } from './once-stub-1'
+
+fn2()

package/src/once.test.ts

@@ -1,5 +1,7 @@
 // @vitest-environment node
 
+import path from 'node:path'
+
 import { describe, it, expect, vi } from 'vitest'
 
 import { once } from './once'
@@ -23,4 +25,31 @@ describe('once', () => {
     const getValue = once(() => value)
     expect(getValue()).toBe(value)
   })
+
+  it('can tree-shake', async () => {
+    const esbuild = await import('esbuild')
+    const cwd = import.meta.dirname
+    const input = path.join(cwd, 'once-stub-2.ts')
+
+    const result = await esbuild.build({
+      entryPoints: [input],
+      format: 'esm',
+      platform: 'neutral',
+      minify: true,
+      bundle: true,
+      write: false,
+      absWorkingDir: cwd,
+    })
+
+    const files = result.outputFiles.map((file) => {
+      return file.text
+    })
+
+    expect(files).toMatchInlineSnapshot(`
+      [
+        "function t(n){let o=!1,e;return()=>(o||(e=n(),o=!0,n=void 0),e)}function r(){console.log("fn1")}var u=t(r);function f(){console.log("fn2")}f();
+      ",
+      ]
+    `)
+  })
 })