feat: cache path parsing function

Author: antfu

packages/devtools/src/app/pages/session/[session].vue

@@ -3,6 +3,7 @@ import type { ModuleListItem, SessionContext } from '../../types/data'
 import { useRoute } from '#app/composables/router'
 import { computed, onMounted, reactive, shallowRef } from 'vue'
 import { backend } from '../../state/backend'
+import { getFileTypeFromName } from '../../utils/icon'
 
 const params = useRoute().params as {
   session: string
@@ -14,9 +15,13 @@ const session = reactive({
 }) as SessionContext
 
 onMounted(async () => {
-  session.modulesList = await backend.value!.functions['vite:rolldown:get-module-list']!({
+  const modules = await backend.value!.functions['vite:rolldown:get-module-list']!({
     session: params.session,
   })
+  session.modulesList = modules.map(mod => ({
+    id: mod.id,
+    fileType: getFileTypeFromName(mod.id).name,
+  }))
 })
 </script>
 

packages/devtools/src/app/types/data.ts

@@ -1,5 +1,6 @@
 export interface ModuleListItem {
   id: string
+  fileType: string
 }
 
 export interface SessionContext {

packages/devtools/src/app/utils/cache.test.ts

@@ -0,0 +1,191 @@
+import { describe, expect, it } from 'vitest'
+import { FixedTupleMap, MaybeWeakMap, TupleMap } from './cache'
+
+describe('maybeWeakMap', () => {
+  it('should work', () => {
+    const map = new MaybeWeakMap<any, any>()
+    map.set('a', 'b')
+    expect(map.get('a')).toBe('b')
+    expect(map.get(1)).toBe(undefined)
+  })
+
+  it('should work with weak keys', () => {
+    const map = new MaybeWeakMap<any, any>()
+    const symbol = Symbol('a')
+    map.set(symbol, 'b')
+    expect(map.get(symbol)).toBe('b')
+  })
+
+  it('should work with object keys', () => {
+    const map = new MaybeWeakMap<any, any>()
+    const obj = {}
+    map.set(obj, 'b')
+    expect(map.get(obj)).toBe('b')
+  })
+})
+
+describe('tupleMap', () => {
+  it('should work', () => {
+    const map = new TupleMap<any, any>()
+    map.set(['a', 'b'], 'c')
+    expect(map.get(['a', 'b'])).toBe('c')
+    expect(map.get(['a'])).toBe(undefined)
+    expect(map.get(['a', 'c'])).toBe(undefined)
+    expect(map.get(['a', 'b', 'c'])).toBe(undefined)
+  })
+
+  it('should work with weak keys', () => {
+    const map = new TupleMap<any, any>()
+    const symbol = Symbol('a')
+    map.set([symbol, 'b'], 'c')
+    expect(map.get([symbol, 'b'])).toBe('c')
+    expect(map.get([symbol])).toBe(undefined)
+    expect(map.get([symbol, 'c'])).toBe(undefined)
+    expect(map.get([symbol, 'b', 'c'])).toBe(undefined)
+    map.set([symbol, 'b'], 'override')
+    expect(map.get([symbol, 'b'])).toBe('override')
+    map.delete([symbol, 'b'])
+    expect(map.get([symbol, 'b'])).toBe(undefined)
+  })
+})
+
+describe('fixedTupleMap', () => {
+  it('error on wrong key length', () => {
+    const map = new FixedTupleMap(5)
+    expect(() => map.set([1, 2, 3], 'a'))
+      .toThrowErrorMatchingInlineSnapshot(`[Error: Expect tuple of length 5, got 3]`)
+  })
+
+  it('iterator', () => {
+    const map = new FixedTupleMap(5)
+    const symbol = Symbol('a')
+    map.set([symbol, 'b', 'c', 'd', 'e'], 'f')
+    map.set([symbol, 'g', 'h', 'i', 'j'], 'k')
+    map.set([symbol, 'l', 'm', 'n', 'o'], 'p')
+    map.set([symbol, 'q', 'r', 's', 't'], 'u')
+    map.set([symbol, 'v', 'w', 'x', 'y'], 'z')
+    map.set([symbol, 'a', 'b', 'c', 'd'], 'e')
+    map.set([symbol, 'f', 'g', 'h', 'i'], 'j')
+    map.set([symbol, 'k', 'l', 'm', 'n'], 'o')
+    map.set([symbol, 'p', 'q', 'r', 's'], 't')
+    map.set([symbol, 'u', 'v', 'w', 'x'], 'y')
+    map.set([symbol, 'z', 'a', 'b', 'c'], 'd')
+
+    const keys = Array.from(map._traverseMap())
+    expect(keys)
+      .toMatchInlineSnapshot(`
+      [
+        {
+          "keys": [
+            Symbol(a),
+            "b",
+            "c",
+            "d",
+            "e",
+          ],
+          "map": "f",
+        },
+        {
+          "keys": [
+            Symbol(a),
+            "g",
+            "h",
+            "i",
+            "j",
+          ],
+          "map": "k",
+        },
+        {
+          "keys": [
+            Symbol(a),
+            "l",
+            "m",
+            "n",
+            "o",
+          ],
+          "map": "p",
+        },
+        {
+          "keys": [
+            Symbol(a),
+            "q",
+            "r",
+            "s",
+            "t",
+          ],
+          "map": "u",
+        },
+        {
+          "keys": [
+            Symbol(a),
+            "v",
+            "w",
+            "x",
+            "y",
+          ],
+          "map": "z",
+        },
+        {
+          "keys": [
+            Symbol(a),
+            "a",
+            "b",
+            "c",
+            "d",
+          ],
+          "map": "e",
+        },
+        {
+          "keys": [
+            Symbol(a),
+            "f",
+            "g",
+            "h",
+            "i",
+          ],
+          "map": "j",
+        },
+        {
+          "keys": [
+            Symbol(a),
+            "k",
+            "l",
+            "m",
+            "n",
+          ],
+          "map": "o",
+        },
+        {
+          "keys": [
+            Symbol(a),
+            "p",
+            "q",
+            "r",
+            "s",
+          ],
+          "map": "t",
+        },
+        {
+          "keys": [
+            Symbol(a),
+            "u",
+            "v",
+            "w",
+            "x",
+          ],
+          "map": "y",
+        },
+        {
+          "keys": [
+            Symbol(a),
+            "z",
+            "a",
+            "b",
+            "c",
+          ],
+          "map": "d",
+        },
+      ]
+    `)
+  })
+})

packages/devtools/src/app/utils/cache.ts

@@ -0,0 +1,162 @@
+/**
+ * An extended `WeakMap` that can also hold regular keys.
+ * (in those cases, it behaves like a regular `Map` and does not free memory)
+ *
+ * An additional `clear` method is added to clear the regular map.
+ */
+export class MaybeWeakMap<K, V> implements WeakMap<any, V> {
+  private _map: Map<K, V>
+  private _weakMap: WeakMap<any, V>
+
+  constructor() {
+    this._map = new Map()
+    this._weakMap = new WeakMap()
+  }
+
+  [Symbol.toStringTag]: string = 'MaybeWeakMap'
+
+  delete(key: K): boolean {
+    if (this._weakMap.has(key))
+      return this._weakMap.delete(key)
+    return this._map.delete(key)
+  }
+
+  has(key: K): boolean {
+    if (this._weakMap.has(key))
+      return true
+    return this._map.has(key)
+  }
+
+  set(key: K, value: V): this {
+    if (this._weakMap.has(key))
+      this._weakMap.set(key, value)
+    else
+      this._map.set(key, value)
+    return this
+  }
+
+  get(key: K): V | undefined {
+    if (this._weakMap.has(key))
+      return this._weakMap.get(key)
+    return this._map.get(key)
+  }
+
+  clear(): void {
+    this._map.clear()
+  }
+}
+
+/**
+ * A `Map` that accepts an array of keys, treating it as a tuple.
+ */
+export class FixedTupleMap<K extends readonly any[], V> {
+  private _mapTree: Map<any, any>
+
+  constructor(
+    public readonly length: K['length'],
+  ) {
+    this._mapTree = new Map()
+  }
+
+  private _getLastMap(key: K): Map<any, any> {
+    let map = this._mapTree
+    for (const k of key.slice(0, -1)) {
+      if (!map.has(k)) {
+        map.set(k, new Map())
+      }
+      map = map.get(k) as Map<any, any>
+    }
+    return map
+  }
+
+  set(key: K, value: V): this {
+    if (key.length !== this.length) {
+      throw new Error(`Expect tuple of length ${this.length}, got ${key.length}`)
+    }
+    const lastMap = this._getLastMap(key)
+    lastMap.set(key[key.length - 1], value)
+    return this
+  }
+
+  get(key: K): V | undefined {
+    const lastMap = this._getLastMap(key)
+    return lastMap.get(key[key.length - 1])
+  }
+
+  clear(): void {
+    this._mapTree.clear()
+  }
+
+  delete(key: K): boolean {
+    const lastMap = this._getLastMap(key)
+    return lastMap.delete(key[key.length - 1])
+  }
+
+  get size(): number {
+    return this._mapTree.size
+  }
+
+  * _traverseMap() {
+    function* traverse(map: Map<any, any>, keys: any[], depthLeft: number): Generator<{ keys: any[], map: Map<any, V> }> {
+      if (depthLeft === 0) {
+        yield { keys, map }
+      }
+      else {
+        for (const [key, value] of map.entries()) {
+          yield* traverse(value, [...keys, key], depthLeft - 1)
+        }
+      }
+    }
+
+    yield* traverse(this._mapTree, [], this.length)
+  }
+}
+
+export class TupleMap<K extends readonly any[], V> {
+  private _lengthMap: Map<number, FixedTupleMap<K, V>>
+
+  constructor() {
+    this._lengthMap = new Map()
+  }
+
+  get(key: K): V | undefined {
+    const length = key.length
+    const map = this._lengthMap.get(length)
+    return map?.get(key)
+  }
+
+  set(key: K, value: V): this {
+    const length = key.length
+    let map = this._lengthMap.get(length)
+    if (!map) {
+      map = new FixedTupleMap(length)
+      this._lengthMap.set(length, map)
+    }
+    map.set(key, value)
+    return this
+  }
+
+  delete(key: K): boolean {
+    const length = key.length
+    const map = this._lengthMap.get(length)
+    return map?.delete(key) ?? false
+  }
+
+  clear(): void {
+    this._lengthMap.clear()
+  }
+}
+
+export function makeCachedFunction<T extends (...args: any[]) => any>(fn: T): T & { cache: TupleMap<Parameters<T>, ReturnType<T>> } {
+  const cache = new TupleMap<Parameters<T>, ReturnType<T>>()
+  const wrapper = function (this: ThisType<T>, ...args: Parameters<T>) {
+    let result = cache.get(args)
+    if (result)
+      return result
+    result = fn(...args)
+    cache.set(args, result!)
+    return result
+  }
+  wrapper.cache = cache
+  return wrapper as T & { cache: TupleMap<Parameters<T>, ReturnType<T>> }
+}