@reallukemanning/folio 1.0.0

package/src/lib/__tests__/filterByFeatured.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest'
+import { filterByFeatured } from '../filterByFeatured'
+import type { FolioProject } from '../../types'
+
+function createProject(overrides: Partial<FolioProject> = {}): FolioProject {
+  return {
+    id: 'test-id',
+    type: 'github',
+    status: 'active',
+    featured: false,
+    name: 'Test Project',
+    tagline: '',
+    description: '',
+    background: null,
+    why: null,
+    image: null,
+    struggles: [],
+    timeline: [],
+    posts: [],
+    stack: [],
+    links: {},
+    stats: null,
+    language: null,
+    languageColor: null,
+    createdAt: null,
+    updatedAt: null,
+    ...overrides,
+  }
+}
+
+describe('filterByFeatured', () => {
+  describe('empty array handling', () => {
+    it('should return empty array when input is empty', () => {
+      expect(filterByFeatured([], true)).toEqual([])
+    })
+
+    it('should return empty array when input is empty and featured is false', () => {
+      expect(filterByFeatured([], false)).toEqual([])
+    })
+
+    it('should return empty array when input is empty and featured is null', () => {
+      expect(filterByFeatured([], null)).toEqual([])
+    })
+
+    it('should return empty array when input is empty and featured is undefined', () => {
+      expect(filterByFeatured([], undefined)).toEqual([])
+    })
+  })
+
+  describe('featured filtering', () => {
+    it('should filter projects with featured=true', () => {
+      const projects = [
+        createProject({ id: '1', featured: true }),
+        createProject({ id: '2', featured: false }),
+        createProject({ id: '3', featured: true }),
+      ]
+
+      const result = filterByFeatured(projects, true)
+
+      expect(result).toHaveLength(2)
+      expect(result.map(p => p.id)).toEqual(['1', '3'])
+    })
+
+    it('should filter projects with featured=false', () => {
+      const projects = [
+        createProject({ id: '1', featured: true }),
+        createProject({ id: '2', featured: false }),
+        createProject({ id: '3', featured: false }),
+      ]
+
+      const result = filterByFeatured(projects, false)
+
+      expect(result).toHaveLength(2)
+      expect(result.map(p => p.id)).toEqual(['2', '3'])
+    })
+
+    it('should return empty array when no projects match featured=true', () => {
+      const projects = [
+        createProject({ featured: false }),
+        createProject({ featured: false }),
+      ]
+
+      const result = filterByFeatured(projects, true)
+
+      expect(result).toHaveLength(0)
+    })
+
+    it('should return empty array when no projects match featured=false', () => {
+      const projects = [
+        createProject({ featured: true }),
+        createProject({ featured: true }),
+      ]
+
+      const result = filterByFeatured(projects, false)
+
+      expect(result).toHaveLength(0)
+    })
+  })
+
+  describe('null and undefined featured parameter', () => {
+    it('should return all projects when featured is null', () => {
+      const projects = [
+        createProject({ id: '1', featured: true }),
+        createProject({ id: '2', featured: false }),
+        createProject({ id: '3', featured: true }),
+      ]
+
+      const result = filterByFeatured(projects, null)
+
+      expect(result).toHaveLength(3)
+    })
+
+    it('should return all projects when featured is undefined', () => {
+      const projects = [
+        createProject({ id: '1', featured: true }),
+        createProject({ id: '2', featured: false }),
+      ]
+
+      const result = filterByFeatured(projects, undefined)
+
+      expect(result).toHaveLength(2)
+    })
+  })
+
+  describe('immutability', () => {
+    it('should not mutate the original array', () => {
+      const projects = [
+        createProject({ id: '1', featured: true }),
+        createProject({ id: '2', featured: false }),
+      ]
+
+      const originalLength = projects.length
+      filterByFeatured(projects, true)
+
+      expect(projects.length).toBe(originalLength)
+    })
+
+    it('should return a new array instance', () => {
+      const projects = [createProject({ featured: true })]
+
+      const result = filterByFeatured(projects, null)
+
+      expect(result).not.toBe(projects)
+    })
+  })
+})

package/src/lib/__tests__/filterByStatus.test.ts

@@ -0,0 +1,193 @@
+import { describe, it, expect } from 'vitest'
+import { filterByStatus } from '../filterByStatus'
+import type { FolioProject, ProjectStatus } from '../../types'
+
+function createProject(overrides: Partial<FolioProject> = {}): FolioProject {
+  return {
+    id: 'test-id',
+    type: 'github',
+    status: 'active',
+    featured: false,
+    name: 'Test Project',
+    tagline: '',
+    description: '',
+    background: null,
+    why: null,
+    image: null,
+    struggles: [],
+    timeline: [],
+    posts: [],
+    stack: [],
+    links: {},
+    stats: null,
+    language: null,
+    languageColor: null,
+    createdAt: null,
+    updatedAt: null,
+    ...overrides,
+  }
+}
+
+describe('filterByStatus', () => {
+  describe('empty array handling', () => {
+    it('should return empty array when input is empty', () => {
+      expect(filterByStatus([], 'active')).toEqual([])
+    })
+
+    it('should return empty array when input is empty and status is undefined', () => {
+      expect(filterByStatus([], undefined)).toEqual([])
+    })
+
+    it('should return empty array when input is empty and status is all', () => {
+      expect(filterByStatus([], 'all')).toEqual([])
+    })
+  })
+
+  describe('status filtering with single status', () => {
+    it('should filter projects by active status', () => {
+      const projects = [
+        createProject({ id: '1', status: 'active' }),
+        createProject({ id: '2', status: 'shipped' }),
+        createProject({ id: '3', status: 'active' }),
+      ]
+
+      const result = filterByStatus(projects, 'active')
+
+      expect(result).toHaveLength(2)
+      expect(result.map(p => p.id)).toEqual(['1', '3'])
+    })
+
+    it('should filter projects by shipped status', () => {
+      const projects = [
+        createProject({ id: '1', status: 'active' }),
+        createProject({ id: '2', status: 'shipped' }),
+        createProject({ id: '3', status: 'in-progress' }),
+      ]
+
+      const result = filterByStatus(projects, 'shipped')
+
+      expect(result).toHaveLength(1)
+      expect(result[0].id).toBe('2')
+    })
+
+    it('should filter projects by archived status', () => {
+      const projects = [
+        createProject({ id: '1', status: 'active' }),
+        createProject({ id: '2', status: 'archived' }),
+      ]
+
+      const result = filterByStatus(projects, 'archived')
+
+      expect(result).toHaveLength(1)
+      expect(result[0].status).toBe('archived')
+    })
+
+    it('should filter projects by for-sale status', () => {
+      const projects = [
+        createProject({ id: '1', status: 'for-sale' }),
+        createProject({ id: '2', status: 'active' }),
+      ]
+
+      const result = filterByStatus(projects, 'for-sale')
+
+      expect(result).toHaveLength(1)
+      expect(result[0].status).toBe('for-sale')
+    })
+
+    it('should return empty array when no projects match status', () => {
+      const projects = [
+        createProject({ status: 'active' }),
+        createProject({ status: 'shipped' }),
+      ]
+
+      const result = filterByStatus(projects, 'archived')
+
+      expect(result).toHaveLength(0)
+    })
+  })
+
+  describe('status filtering with array of statuses', () => {
+    it('should filter projects by multiple statuses', () => {
+      const projects = [
+        createProject({ id: '1', status: 'active' }),
+        createProject({ id: '2', status: 'shipped' }),
+        createProject({ id: '3', status: 'archived' }),
+        createProject({ id: '4', status: 'in-progress' }),
+      ]
+
+      const result = filterByStatus(projects, ['active', 'shipped'] as ProjectStatus[])
+
+      expect(result).toHaveLength(2)
+      expect(result.map(p => p.id)).toEqual(['1', '2'])
+    })
+
+    it('should handle empty status array', () => {
+      const projects = [
+        createProject({ id: '1', status: 'active' }),
+      ]
+
+      const result = filterByStatus(projects, [])
+
+      expect(result).toHaveLength(0)
+    })
+
+    it('should filter by all valid status values', () => {
+      const allStatuses: ProjectStatus[] = ['active', 'shipped', 'in-progress', 'coming-soon', 'archived', 'for-sale']
+      const projects = allStatuses.map((status, i) => createProject({ id: String(i), status }))
+
+      const result = filterByStatus(projects, ['active', 'shipped', 'archived'] as ProjectStatus[])
+
+      expect(result).toHaveLength(3)
+      expect(result.map(p => p.status)).toEqual(['active', 'shipped', 'archived'])
+    })
+  })
+
+  describe('special status values', () => {
+    it('should return all projects when status is "all"', () => {
+      const projects = [
+        createProject({ id: '1', status: 'active' }),
+        createProject({ id: '2', status: 'shipped' }),
+        createProject({ id: '3', status: 'archived' }),
+      ]
+
+      const result = filterByStatus(projects, 'all')
+
+      expect(result).toHaveLength(3)
+    })
+
+    it('should return all projects when status is undefined', () => {
+      const projects = [
+        createProject({ id: '1', status: 'active' }),
+        createProject({ id: '2', status: 'shipped' }),
+      ]
+
+      const result = filterByStatus(projects, undefined)
+
+      expect(result).toHaveLength(2)
+    })
+  })
+
+  describe('immutability', () => {
+    it('should not mutate the original array', () => {
+      const projects = [
+        createProject({ id: '1', status: 'active' }),
+        createProject({ id: '2', status: 'shipped' }),
+      ]
+
+      const originalLength = projects.length
+      filterByStatus(projects, 'active')
+
+      expect(projects.length).toBe(originalLength)
+    })
+
+    it('should return a new array instance', () => {
+      const projects = [
+        createProject({ status: 'active' }),
+      ]
+
+      const result = filterByStatus(projects, 'all')
+
+      expect(result).not.toBe(projects)
+    })
+  })
+})

package/src/lib/__tests__/filterByType.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest'
+import { filterByType } from '../filterByType'
+import type { FolioProject, ProjectType } from '../../types'
+
+function createProject(overrides: Partial<FolioProject> = {}): FolioProject {
+  return {
+    id: 'test-id',
+    type: 'github',
+    status: 'active',
+    featured: false,
+    name: 'Test Project',
+    tagline: '',
+    description: '',
+    background: null,
+    why: null,
+    image: null,
+    struggles: [],
+    timeline: [],
+    posts: [],
+    stack: [],
+    links: {},
+    stats: null,
+    language: null,
+    languageColor: null,
+    createdAt: null,
+    updatedAt: null,
+    ...overrides,
+  }
+}
+
+describe('filterByType', () => {
+  describe('empty array handling', () => {
+    it('should return empty array when input is empty', () => {
+      expect(filterByType([], 'github')).toEqual([])
+    })
+
+    it('should return empty array when input is empty and type is undefined', () => {
+      expect(filterByType([], undefined)).toEqual([])
+    })
+
+    it('should return empty array when input is empty and type is all', () => {
+      expect(filterByType([], 'all')).toEqual([])
+    })
+  })
+
+  describe('type filtering', () => {
+    it('should filter projects by github type', () => {
+      const projects = [
+        createProject({ id: '1', type: 'github' }),
+        createProject({ id: '2', type: 'manual' }),
+        createProject({ id: '3', type: 'github' }),
+      ]
+
+      const result = filterByType(projects, 'github')
+
+      expect(result).toHaveLength(2)
+      expect(result.map(p => p.id)).toEqual(['1', '3'])
+    })
+
+    it('should filter projects by npm type', () => {
+      const projects = [
+        createProject({ id: '1', type: 'github' }),
+        createProject({ id: '2', type: 'npm' }),
+        createProject({ id: '3', type: 'npm' }),
+      ]
+
+      const result = filterByType(projects, 'npm')
+
+      expect(result).toHaveLength(2)
+      expect(result.map(p => p.id)).toEqual(['2', '3'])
+    })
+
+    it('should filter projects by product-hunt type', () => {
+      const projects = [
+        createProject({ id: '1', type: 'product-hunt' }),
+        createProject({ id: '2', type: 'github' }),
+      ]
+
+      const result = filterByType(projects, 'product-hunt')
+
+      expect(result).toHaveLength(1)
+      expect(result[0].type).toBe('product-hunt')
+    })
+
+    it('should filter projects by hybrid type', () => {
+      const projects = [
+        createProject({ id: '1', type: 'hybrid' }),
+        createProject({ id: '2', type: 'github' }),
+        createProject({ id: '3', type: 'hybrid' }),
+      ]
+
+      const result = filterByType(projects, 'hybrid')
+
+      expect(result).toHaveLength(2)
+      expect(result.map(p => p.type)).toEqual(['hybrid', 'hybrid'])
+    })
+
+    it('should filter projects by manual type', () => {
+      const projects = [
+        createProject({ id: '1', type: 'manual' }),
+        createProject({ id: '2', type: 'github' }),
+      ]
+
+      const result = filterByType(projects, 'manual')
+
+      expect(result).toHaveLength(1)
+      expect(result[0].type).toBe('manual')
+    })
+
+    it('should return empty array when no projects match type', () => {
+      const projects = [
+        createProject({ type: 'github' }),
+        createProject({ type: 'npm' }),
+      ]
+
+      const result = filterByType(projects, 'manual')
+
+      expect(result).toHaveLength(0)
+    })
+  })
+
+  describe('all types coverage', () => {
+    it('should correctly filter for all ProjectType values', () => {
+      const allTypes: ProjectType[] = ['github', 'npm', 'product-hunt', 'hybrid', 'manual']
+
+      allTypes.forEach(targetType => {
+        const projects = allTypes.map((type, i) => createProject({ id: String(i), type }))
+        const result = filterByType(projects, targetType)
+
+        expect(result).toHaveLength(1)
+        expect(result[0].type).toBe(targetType)
+      })
+    })
+  })
+
+  describe('special type values', () => {
+    it('should return all projects when type is "all"', () => {
+      const projects = [
+        createProject({ id: '1', type: 'github' }),
+        createProject({ id: '2', type: 'npm' }),
+        createProject({ id: '3', type: 'manual' }),
+      ]
+
+      const result = filterByType(projects, 'all')
+
+      expect(result).toHaveLength(3)
+    })
+
+    it('should return all projects when type is undefined', () => {
+      const projects = [
+        createProject({ id: '1', type: 'github' }),
+        createProject({ id: '2', type: 'npm' }),
+      ]
+
+      const result = filterByType(projects, undefined)
+
+      expect(result).toHaveLength(2)
+    })
+  })
+
+  describe('immutability', () => {
+    it('should not mutate the original array', () => {
+      const projects = [
+        createProject({ id: '1', type: 'github' }),
+        createProject({ id: '2', type: 'npm' }),
+      ]
+
+      const originalLength = projects.length
+      filterByType(projects, 'github')
+
+      expect(projects.length).toBe(originalLength)
+    })
+
+    it('should return a new array instance', () => {
+      const projects = [createProject({ type: 'github' })]
+
+      const result = filterByType(projects, 'all')
+
+      expect(result).not.toBe(projects)
+    })
+  })
+})