fix: filter adobe font results

src/providers/adobe.ts

@@ -67,7 +67,14 @@ export default defineFontProvider<ProviderOption>('adobe', async (options, ctx)
       // TODO: Not sure whether this css_names array always has a single element. Still need to investigate.
       const cssName = font.css_names[0] ?? family.toLowerCase().split(' ').join('-')
 
-      return extractFontFaceData(css, cssName)
+      return extractFontFaceData(css, cssName).filter((font) => {
+        const [lowerWeight, upperWeight] = Array.isArray(font.weight) ? font.weight : [0, 0]
+
+        return (
+          (!options.styles || !font.style || options.styles.includes(font.style as 'normal'))
+          && (!options.weights || !font.weight || Array.isArray(font.weight) ? options.weights.some(weight => Number(weight) <= upperWeight || Number(weight) >= lowerWeight) : options.weights.includes(String(font.weight)))
+        )
+      })
     }
 
     return []

test/providers/adobe.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest'
+import { createUnifont, providers } from '../../src'
+import { pickUniqueBy } from '../utils'
+
+describe('adobe', () => {
+  it('correctly types options for adobe provider', async () => {
+    providers.adobe({ id: [] })
+    // @ts-expect-error options must be provided
+    providers.adobe()
+
+    expect(true).toBe(true)
+  })
+
+  it('works', async () => {
+    const unifont = await createUnifont([providers.adobe({ id: ['sij5ufr', 'grx7wdj'] })])
+
+    const { fonts: aleo } = await unifont.resolveFont('Aleo')
+    const normalised = aleo.map(f => ({
+      ...f,
+      src: f.src.map(s => ({ ...s, url: 'url' in s ? s.url.replace(/https:\/\/use\.typekit\.net\/.*$/, '<some-font-url>') : undefined })),
+    }))
+
+    expect(normalised).toMatchInlineSnapshot(`
+      [
+        {
+          "display": "auto",
+          "src": [
+            {
+              "format": "woff2",
+              "url": "<some-font-url>",
+            },
+            {
+              "format": "woff",
+              "url": "<some-font-url>",
+            },
+            {
+              "format": "opentype",
+              "url": "<some-font-url>",
+            },
+          ],
+          "style": "italic",
+          "weight": 400,
+        },
+        {
+          "display": "auto",
+          "src": [
+            {
+              "format": "woff2",
+              "url": "<some-font-url>",
+            },
+            {
+              "format": "woff",
+              "url": "<some-font-url>",
+            },
+            {
+              "format": "opentype",
+              "url": "<some-font-url>",
+            },
+          ],
+          "style": "normal",
+          "weight": 400,
+        },
+      ]
+    `)
+
+    const weights = ['400']
+    const styles = ['italic'] as Array<'italic'>
+
+    const barlow = await unifont.resolveFont('Barlow Semi Condensed', { weights, styles, subsets: [] }).then(r => r.fonts)
+
+    const resolvedStyles = pickUniqueBy(barlow, fnt => fnt.style)
+    const resolvedWeights = pickUniqueBy(barlow, fnt => String(fnt.weight))
+
+    expect(barlow).toHaveLength(1)
+    expect(resolvedStyles).toMatchObject(styles)
+    expect(resolvedWeights).toMatchObject(weights)
+  })
+})

test/utils/index.ts

@@ -0,0 +1,9 @@
+// Quick and dirty way to pick into a new array, not needed if the test is un-necessary
+export function pickUniqueBy<T, K>(arr: T[], by: (arg: T) => K): K[] {
+  return [...arr.reduce((acc, fnt) => {
+    const prop = by(fnt)
+    if (!acc.has(prop))
+      acc.add(prop)
+    return acc
+  }, new Set<K>())]
+}