recipe-scrapers-js 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/index.js

@@ -18,11 +18,13 @@ function isString(value) {
 	return typeof value === "string";
 }
 /**
-* Extracts the host name from a URL string.
+* Extracts the host name from a URL string
+* and removes 'www.' prefix if present.
+* Throws an error if the input is not a valid URL.
 */
 function getHostName(value) {
 	try {
-		const url = new URL(value);
+		const url = new URL(value.replace("www.", ""));
 		return url.host;
 	} catch {
 		throw new Error(`Invalid URL: ${value}`);
@@ -280,7 +282,7 @@ var HtmlStripperPlugin = class extends PostProcessorPlugin {
 		return ingredients;
 	}
 	stripHtml(html) {
-		return html.replace(/<[^>]*>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#34;/g, "\"").replace(/&#39;/g, "'").trim();
+		return html.replace(/<[^>]*>/g, "").replace(/&amp;/g, "&").replace(/&nbsp;/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#34;/g, "\"").replace(/&#39;/g, "'").trim();
 	}
 };
 
@@ -650,7 +652,7 @@ var SchemaOrgPlugin = class SchemaOrgPlugin extends ExtractorPlugin {
 		"title",
 		"@id"
 	]) {
-		let text = void 0;
+		let text;
 		if (isString(value)) text = value;
 		else if (isNumber(value)) text = value.toString();
 		else if (Array.isArray(value)) text = this.getSchemaTextValue(value[0], props);
@@ -1017,31 +1019,31 @@ var AbstractScraper = class {
 		const instance = this.constructor;
 		if (this.recipeData) return this.recipeData;
 		this.recipeData = {
-			host: instance.host(),
-			siteName: await this.extract("siteName"),
 			author: await this.extract("author"),
-			title: await this.extract("title"),
-			image: await this.extract("image"),
 			canonicalUrl: this.canonicalUrl(),
-			language: this.language(),
-			links: this.links(),
+			category: await this.extract("category"),
+			cookTime: await this.extract("cookTime"),
+			cookingMethod: await this.extract("cookingMethod"),
+			cuisine: await this.extract("cuisine"),
 			description: await this.extract("description"),
+			dietaryRestrictions: await this.extract("dietaryRestrictions"),
+			equipment: await this.extract("equipment"),
+			host: instance.host(),
+			image: await this.extract("image"),
 			ingredients: await this.extract("ingredients"),
 			instructions: await this.extract("instructions"),
-			category: await this.extract("category"),
-			yields: await this.extract("yields"),
-			totalTime: await this.extract("totalTime"),
-			cookTime: await this.extract("cookTime"),
+			keywords: await this.extract("keywords"),
+			language: this.language(),
+			links: this.links(),
+			nutrients: await this.extract("nutrients"),
 			prepTime: await this.extract("prepTime"),
-			cuisine: await this.extract("cuisine"),
-			cookingMethod: await this.extract("cookingMethod"),
 			ratings: await this.extract("ratings"),
 			ratingsCount: await this.extract("ratingsCount"),
-			equipment: await this.extract("equipment"),
 			reviews: await this.extract("reviews"),
-			nutrients: await this.extract("nutrients"),
-			dietaryRestrictions: await this.extract("dietaryRestrictions"),
-			keywords: await this.extract("keywords")
+			siteName: await this.extract("siteName"),
+			title: await this.extract("title"),
+			totalTime: await this.extract("totalTime"),
+			yields: await this.extract("yields")
 		};
 		return this.recipeData;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recipe-scrapers-js",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.5",
   "license": "MIT",
   "description": "A recipe scrapers library",
   "author": {
@@ -12,11 +12,21 @@
     "url": "git+https://github.com/nerdstep/recipe-scrapers-js.git"
   },
   "type": "module",
-  "module": "src/index.ts",
+  "module": "dist/index.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["dist", "src", "README.md", "LICENSE"],
-  "keywords": ["recipe", "scraper", "parser", "food", "cooking"],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "recipe",
+    "scraper",
+    "parser",
+    "food",
+    "cooking"
+  ],
   "scripts": {
     "build": "tsdown src/index.ts --outdir dist",
     "test": "bun test",
@@ -29,17 +39,17 @@
     "prepublishOnly": "bun run lint && bun run build"
   },
   "peerDependencies": {
-    "cheerio": "^1.0.0"
+    "cheerio": "^1.1.0"
   },
   "dependencies": {
     "iso8601-duration": "^2.1.2",
     "schema-dts": "^1.1.5"
   },
   "devDependencies": {
-    "@biomejs/biome": "^1.9.4",
-    "@types/bun": "^1.2.15",
-    "cheerio": "^1.0.0",
-    "tsdown": "^0.12.7",
+    "@biomejs/biome": "^2.0.6",
+    "@types/bun": "^1.2.17",
+    "cheerio": "^1.1.0",
+    "tsdown": "^0.12.9",
     "typescript": "^5.8.3"
   }
 }

package/src/__tests__/abstract-extractor-plugin.test.ts

@@ -1,234 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test'
-import {
-  NotImplementedException,
-  UnsupportedFieldException,
-} from '@/exceptions'
-import { load } from 'cheerio'
-import { ExtractorPlugin } from '../abstract-extractor-plugin'
-import type { RecipeFields } from '../types/recipe.interface'
-
-class MockExtractorPlugin extends ExtractorPlugin {
-  name = 'MockExtractorPlugin'
-  priority = 100
-
-  private supportedFields: Set<keyof RecipeFields>
-
-  constructor(supportedFields: (keyof RecipeFields)[] = []) {
-    const $ = load('<html><body></body></html>')
-    super($)
-    this.supportedFields = new Set(supportedFields)
-  }
-
-  supports(field: keyof RecipeFields): boolean {
-    return this.supportedFields.has(field)
-  }
-
-  extract<Key extends keyof RecipeFields>(field: Key): RecipeFields[Key] {
-    if (!this.supports(field)) {
-      throw new UnsupportedFieldException(field)
-    }
-
-    // Mock extraction logic
-    switch (field) {
-      case 'title':
-        return 'Mock Recipe Title' as RecipeFields[Key]
-      case 'description':
-        return 'Mock Recipe Description' as RecipeFields[Key]
-      case 'ingredients':
-        return new Set(['ingredient 1', 'ingredient 2']) as RecipeFields[Key]
-      case 'instructions':
-        return new Set(['step 1', 'step 2']) as RecipeFields[Key]
-      case 'prepTime':
-        return 15 as RecipeFields[Key]
-      case 'cookTime':
-        return 30 as RecipeFields[Key]
-      case 'totalTime':
-        return 45 as RecipeFields[Key]
-      case 'yields':
-        return '4 servings' as RecipeFields[Key]
-      default:
-        throw new NotImplementedException(field)
-    }
-  }
-}
-
-class AsyncMockExtractorPlugin extends ExtractorPlugin {
-  name = 'AsyncMockExtractorPlugin'
-  priority = 100
-
-  constructor() {
-    const $ = load('<html><body></body></html>')
-    super($)
-  }
-
-  supports(field: keyof RecipeFields): boolean {
-    return ['title', 'description'].includes(field)
-  }
-
-  async extract<Key extends keyof RecipeFields>(
-    field: Key,
-  ): Promise<RecipeFields[Key]> {
-    await new Promise((resolve) => setTimeout(resolve, 10))
-
-    if (!this.supports(field)) {
-      throw new UnsupportedFieldException(field)
-    }
-
-    switch (field) {
-      case 'title':
-        return 'Async Recipe Title' as RecipeFields[Key]
-      case 'description':
-        return 'Async Recipe Description' as RecipeFields[Key]
-      default:
-        throw new NotImplementedException(field)
-    }
-  }
-}
-
-class ThrowingExtractorPlugin extends ExtractorPlugin {
-  name = 'ThrowingExtractorPlugin'
-  priority = 100
-
-  constructor() {
-    const $ = load('<html><body></body></html>')
-    super($)
-  }
-
-  supports(field: keyof RecipeFields): boolean {
-    return true
-  }
-
-  extract<Key extends keyof RecipeFields>(field: Key): RecipeFields[Key] {
-    throw new Error(`Extraction failed for field: ${String(field)}`)
-  }
-}
-
-describe('ExtractorPlugin', () => {
-  let plugin: MockExtractorPlugin
-
-  beforeEach(() => {
-    plugin = new MockExtractorPlugin([
-      'title',
-      'description',
-      'ingredients',
-      'prepTime',
-    ])
-  })
-
-  describe('inheritance', () => {
-    it('should extend AbstractPlugin', () => {
-      expect(plugin).toBeInstanceOf(ExtractorPlugin)
-    })
-
-    it('should have access to cheerio instance from parent', () => {
-      expect(plugin.$).toBeDefined()
-      expect(typeof plugin.$).toBe('function')
-    })
-  })
-
-  describe('supports method', () => {
-    it('should return true for supported fields', () => {
-      expect(plugin.supports('title')).toBe(true)
-      expect(plugin.supports('description')).toBe(true)
-      expect(plugin.supports('ingredients')).toBe(true)
-      expect(plugin.supports('prepTime')).toBe(true)
-    })
-
-    it('should return false for unsupported fields', () => {
-      expect(plugin.supports('cookTime')).toBe(false)
-      expect(plugin.supports('totalTime')).toBe(false)
-      expect(plugin.supports('yields')).toBe(false)
-      expect(plugin.supports('author')).toBe(false)
-    })
-
-    it('should handle empty supported fields', () => {
-      const emptyPlugin = new MockExtractorPlugin([])
-      expect(emptyPlugin.supports('title')).toBe(false)
-      expect(emptyPlugin.supports('description')).toBe(false)
-    })
-
-    it('should handle all fields as supported', () => {
-      const allFieldsPlugin = new MockExtractorPlugin([
-        'title',
-        'description',
-        'ingredients',
-        'instructions',
-        'prepTime',
-        'cookTime',
-        'totalTime',
-        'yields',
-      ])
-
-      expect(allFieldsPlugin.supports('title')).toBe(true)
-      expect(allFieldsPlugin.supports('cookTime')).toBe(true)
-      expect(allFieldsPlugin.supports('yields')).toBe(true)
-    })
-  })
-
-  describe('extract method', () => {
-    it('should extract supported fields', () => {
-      expect(plugin.extract('title')).toBe('Mock Recipe Title')
-      expect(plugin.extract('description')).toBe('Mock Recipe Description')
-      expect(plugin.extract('prepTime')).toBe(15)
-      expect(plugin.extract('ingredients')).toEqual(
-        new Set(['ingredient 1', 'ingredient 2']),
-      )
-    })
-
-    it('should throw error for unsupported fields', () => {
-      expect(() => plugin.extract('cookTime')).toThrow(
-        'Extraction not supported for field: cookTime',
-      )
-      expect(() => plugin.extract('totalTime')).toThrow(
-        'Extraction not supported for field: totalTime',
-      )
-    })
-  })
-
-  describe('async extraction', () => {
-    let asyncPlugin: AsyncMockExtractorPlugin
-
-    beforeEach(() => {
-      asyncPlugin = new AsyncMockExtractorPlugin()
-    })
-
-    it('should handle async extraction', async () => {
-      const title = await asyncPlugin.extract('title')
-      expect(title).toBe('Async Recipe Title')
-      const description = await asyncPlugin.extract('description')
-      expect(description).toBe('Async Recipe Description')
-    })
-
-    it('should throw error for unsupported fields in async mode', async () => {
-      await expect(asyncPlugin.extract('cookTime')).rejects.toThrow(
-        'Extraction not supported for field: cookTime',
-      )
-    })
-  })
-
-  describe('error handling', () => {
-    let throwingPlugin: ThrowingExtractorPlugin
-
-    beforeEach(() => {
-      throwingPlugin = new ThrowingExtractorPlugin()
-    })
-
-    it('should propagate extraction errors', () => {
-      expect(() => throwingPlugin.extract('title')).toThrow(
-        'Extraction failed for field: title',
-      )
-      expect(() => throwingPlugin.extract('description')).toThrow(
-        'Extraction failed for field: description',
-      )
-    })
-  })
-
-  describe('edge cases', () => {
-    it('should throw on undefined extractor', () => {
-      const plugin = new MockExtractorPlugin(['author'])
-      expect(() => plugin.extract('author')).toThrow(
-        'Method should be implemented: author',
-      )
-    })
-  })
-})

package/src/__tests__/abstract-scraper.test.ts

@@ -1,201 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, spyOn } from 'bun:test'
-import { AbstractScraper } from '@/abstract-scraper'
-import { NotImplementedException } from '@/exceptions'
-import { Logger } from '@/logger'
-import type { RecipeFields, RecipeObject } from '@/types/recipe.interface'
-
-class DummyScraper extends AbstractScraper {
-  // implement required static host
-  static host(): string {
-    return 'dummy.com'
-  }
-  // no site-specific extractors
-  extractors = {}
-}
-
-describe('AbstractScraper utility methods', () => {
-  let scraper: DummyScraper
-
-  describe('static host()', () => {
-    it('throws by default on base class', () => {
-      expect(() => AbstractScraper.host()).toThrow(NotImplementedException)
-    })
-
-    it('returns host for subclass', () => {
-      expect(DummyScraper.host()).toBe('dummy.com')
-    })
-  })
-
-  describe('canonicalUrl()', () => {
-    it('returns absolute canonical URL when provided', () => {
-      const html = '<link rel="canonical" href="/foo/bar"/>'
-      scraper = new DummyScraper(html, 'http://example.com/page', {})
-      expect(scraper.canonicalUrl()).toBe('http://example.com/foo/bar')
-    })
-
-    it('returns base URL when no canonical link', () => {
-      const html = '<html></html>'
-      scraper = new DummyScraper(html, 'https://site.org/path?x=1', {})
-      expect(scraper.canonicalUrl()).toBe('https://site.org/path?x=1')
-    })
-
-    it('prefixes URL with https when missing protocol', () => {
-      const html = ''
-      scraper = new DummyScraper(html, 'site.org/abc', {})
-      expect(scraper.canonicalUrl()).toBe('https://site.org/abc')
-    })
-  })
-
-  describe('language()', () => {
-    let warnSpy: ReturnType<typeof spyOn>
-
-    beforeEach(() => {
-      warnSpy = spyOn(Logger.prototype, 'warn').mockImplementation(() => {})
-    })
-    afterEach(() => {
-      warnSpy.mockRestore()
-    })
-
-    it('reads html lang attribute', () => {
-      const html = '<html lang="fr"><body></body></html>'
-      scraper = new DummyScraper(html, 'url', {})
-      expect(scraper.language()).toBe('fr')
-      expect(warnSpy).not.toHaveBeenCalled()
-    })
-
-    it('falls back to meta http-equiv content-language', () => {
-      const html =
-        '<html><head>' +
-        '<meta http-equiv="content-language" content="de, en"/>' +
-        '</head></html>'
-      scraper = new DummyScraper(html, 'url', {})
-      expect(scraper.language()).toBe('de')
-      expect(warnSpy).not.toHaveBeenCalled()
-    })
-
-    it('defaults to "en" and logs warning when none found', () => {
-      scraper = new DummyScraper('<html></html>', 'url', {})
-      expect(scraper.language()).toBe('en')
-      expect(warnSpy).toHaveBeenCalledWith('Could not determine language')
-    })
-  })
-
-  describe('links()', () => {
-    const html = `
-      <a href="http://foo.com/page">Foo</a>
-      <a href="/local">Local</a>
-      <a>No href</a>
-    `
-    it('returns empty list when linksEnabled is false', () => {
-      scraper = new DummyScraper(html, 'url', { linksEnabled: false })
-      expect(scraper.links()).toEqual([])
-    })
-
-    it('returns only absolute links when linksEnabled is true', () => {
-      scraper = new DummyScraper(html, 'url', { linksEnabled: true })
-      const links = scraper.links()
-      expect(links).toEqual([{ href: 'http://foo.com/page', text: 'Foo' }])
-    })
-  })
-})
-
-// Test subclass overriding extract, canonicalUrl, language, links, and host
-class TestScraper extends AbstractScraper {
-  static host(): string {
-    return 'hostVal'
-  }
-
-  // Provide no real HTML parsing
-  extractors = {}
-  private data: Partial<Record<keyof RecipeFields, unknown>>
-  constructor(data: Partial<Record<keyof RecipeFields, unknown>>) {
-    // html, url and options are unused because we override methods
-    super('', '', { linksEnabled: true })
-    this.data = data
-  }
-
-  // Return mocked values for every field
-  async extract<Key extends keyof RecipeFields>(
-    field: Key,
-  ): Promise<RecipeFields[Key]> {
-    return this.data[field] as RecipeFields[Key]
-  }
-
-  override canonicalUrl(): string {
-    return this.data.canonicalUrl as string
-  }
-  override language(): string {
-    return this.data.language as string
-  }
-  override links(): RecipeFields['links'] {
-    return this.data.links as RecipeFields['links']
-  }
-}
-
-describe('AbstractScraper.toObject', () => {
-  it('returns a fully serialized RecipeObject', async () => {
-    // Prepare mock values
-    const mockValues: Partial<Record<keyof RecipeFields, unknown>> = {
-      siteName: 'site',
-      author: 'auth',
-      title: 'ttl',
-      image: 'img',
-      description: 'desc',
-      yields: '4 servings',
-      totalTime: 30,
-      cookTime: 10,
-      prepTime: 20,
-      cookingMethod: 'bake',
-      ratings: 4.2,
-      ratingsCount: 100,
-      category: new Set(['cat1', 'cat2']),
-      cuisine: new Set(['cui']),
-      dietaryRestrictions: new Set(['veg']),
-      equipment: new Set(['pan']),
-      ingredients: new Set(['ing1', 'ing2']),
-      instructions: new Set(['step1', 'step2']),
-      keywords: new Set(['kw1']),
-      nutrients: new Map([['cal', '200kcal']]),
-      reviews: new Map([['rev1', 'Good']]),
-      canonicalUrl: 'http://can.url',
-      language: 'en-US',
-      links: [{ href: 'http://link', text: 'LinkText' }],
-    }
-
-    const scraper = new TestScraper(mockValues)
-    const result = await scraper.toObject()
-
-    // Basic scalar fields
-    const expectedRest = {
-      host: 'hostVal',
-      siteName: 'site',
-      author: 'auth',
-      title: 'ttl',
-      image: 'img',
-      canonicalUrl: 'http://can.url',
-      language: 'en-US',
-      links: [{ href: 'http://link', text: 'LinkText' }],
-      description: 'desc',
-      yields: '4 servings',
-      totalTime: 30,
-      cookTime: 10,
-      prepTime: 20,
-      cookingMethod: 'bake',
-      ratings: 4.2,
-      ratingsCount: 100,
-    }
-
-    expect(result).toEqual({
-      ...expectedRest,
-      category: ['cat1', 'cat2'],
-      cuisine: ['cui'],
-      dietaryRestrictions: ['veg'],
-      equipment: ['pan'],
-      ingredients: ['ing1', 'ing2'],
-      instructions: ['step1', 'step2'],
-      keywords: ['kw1'],
-      nutrients: { cal: '200kcal' },
-      reviews: { rev1: 'Good' },
-    } as RecipeObject)
-  })
-})