polen 0.11.0-next.13 → 0.11.0-next.15

package/src/lib/task/task.ts

@@ -1,14 +1,19 @@
 import type { Mask } from '#lib/mask'
+import { Effect } from 'effect'
 import type { Report } from './report.js'
 import { exitWithReport } from './report.js'
 
+// ============================================================================
+// Types
+// ============================================================================
+
 export interface Definition<$Input = any, $Output = any> {
   name: string
-  mask?: MaskOptions<$Input, $Output>
+  mask?: MaskOptions<$Input, $Output> | undefined
 }
 
-export interface Task<$Input, $Output> {
-  (input: $Input): Promise<Report<$Input, $Output>>
+export interface Task<$Input, $Output, $Error = never, $Requirements = never> {
+  (input: $Input): Effect.Effect<Report<$Input, $Output>, $Error, $Requirements>
   definition: Definition<$Input, $Output>
 }
 
@@ -23,60 +28,66 @@ export interface MaskOptions<$Input, $Output> {
   output?: Mask.InferOptions<$Output>
 }
 
-export const create = <$Input, $Output>(
-  fn: (input: $Input) => Promise<$Output>,
+// ============================================================================
+// Core Functions
+// ============================================================================
+
+export const create = <$Input, $Output, $Error = never, $Requirements = never>(
+  fn: (input: $Input) => Effect.Effect<$Output, $Error, $Requirements>,
   options?: {
     /**
      * @default the fn name
      */
-    name?: string
+    name?: string | undefined
     /**
      * An optional default mask to use for successfully returned values.
      */
-    mask?: MaskOptions<$Input, $Output>
+    mask?: MaskOptions<$Input, $Output> | undefined
   },
-): Task<$Input, $Output> => {
+): Task<$Input, $Output, $Error, $Requirements> => {
   const definition: Definition<$Input, $Output> = {
-    name: options?.name ?? (fn.name || `anonymous`),
+    name: options?.name ?? 'anonymous',
     mask: options?.mask,
   }
 
-  const task = async (input: $Input): Promise<Report<$Input, $Output>> => {
-    const start = performance.now()
+  const task = (input: $Input): Effect.Effect<Report<$Input, $Output>, $Error, $Requirements> =>
+    Effect.gen(function*() {
+      const start = performance.now()
 
-    try {
-      const output = await fn(input)
-      const end = performance.now()
+      const result = yield* fn(input).pipe(
+        Effect.either,
+      )
 
-      return {
-        task: definition,
-        execution: {
-          input,
-          output,
-          timings: {
-            start,
-            end,
-            duration: end - start,
-          },
-        },
-      }
-    } catch (error) {
       const end = performance.now()
 
-      return {
-        task: definition,
-        execution: {
-          input,
-          output: error as Error,
-          timings: {
-            start,
-            end,
-            duration: end - start,
+      if (result._tag === 'Right') {
+        return {
+          task: definition,
+          execution: {
+            input,
+            output: result.right,
+            timings: {
+              start,
+              end,
+              duration: end - start,
+            },
           },
-        },
+        }
+      } else {
+        return {
+          task: definition,
+          execution: {
+            input,
+            output: result.left as Error,
+            timings: {
+              start,
+              end,
+              duration: end - start,
+            },
+          },
+        }
       }
-    }
-  }
+    })
 
   task.definition = definition
 
@@ -91,22 +102,28 @@ export const create = <$Input, $Output>(
  * @param input - Input to pass to the task
  * @param options - Combined task creation and format options
  */
-export const runAndExit = async <$Input, $Output>(
-  fn: (input: $Input) => Promise<$Output>,
+export const runAndExit = <$Input, $Output, $Error = never, $Requirements = never>(
+  fn: (input: $Input) => Effect.Effect<$Output, $Error, $Requirements>,
   input: $Input,
   options?: {
-    name?: string
-    mask?: MaskOptions<$Input, $Output>
-    debug?: boolean
+    name?: string | undefined
+    mask?: MaskOptions<$Input, $Output> | undefined
+    debug?: boolean | undefined
   },
-): Promise<never> => {
-  const task = create(fn, {
-    name: options?.name,
-    mask: options?.mask,
-  })
-  const report = await task(input)
-  return exitWithReport(report, {
-    debug: options?.debug,
-    mask: options?.mask,
-  })
-}
+): Effect.Effect<never, never, $Requirements> =>
+  Effect.gen(function*() {
+    const task = create(fn, {
+      name: options?.name,
+      mask: options?.mask,
+    })
+    // The task function handles errors internally and wraps them in the report
+    // so it should never fail - it always returns a Report
+    const report = yield* task(input)
+    // exitWithReport calls process.exit, so it never returns
+    exitWithReport(report, {
+      debug: options?.debug,
+      mask: options?.mask,
+    })
+    // This line will never be reached, but TypeScript needs it for the never type
+    return yield* Effect.die('unreachable')
+  }) as Effect.Effect<never, never, $Requirements>

package/src/lib/theme/theme.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, test, vi } from 'vitest'
+import { Test } from '../../../tests/unit/helpers/test.js'
 import { createThemeManager } from './theme.js'
 
 // Mock document and window
@@ -45,50 +46,29 @@ describe('Theme', () => {
     })
   })
 
-  describe('readCookie', () => {
-    test('reads theme from cookie string', () => {
-      const manager = createThemeManager()
-
-      expect(manager.readCookie('theme=dark')).toBe('dark')
-      expect(manager.readCookie('theme=light')).toBe('light')
-      expect(manager.readCookie('other=value; theme=dark; more=stuff')).toBe('dark')
-    })
-
-    test('returns null for invalid theme values', () => {
-      const manager = createThemeManager()
-
-      expect(manager.readCookie('theme=invalid')).toBe(null)
-      expect(manager.readCookie('theme=')).toBe(null)
-      expect(manager.readCookie('other=value')).toBe(null)
-      expect(manager.readCookie('')).toBe(null)
-    })
-
-    test('handles custom cookie name', () => {
-      const manager = createThemeManager({ cookieName: 'my-theme' })
-
-      expect(manager.readCookie('my-theme=dark')).toBe('dark')
-      expect(manager.readCookie('theme=dark')).toBe(null) // wrong name
-    })
+  // dprint-ignore
+  Test.suite<{ cookieString: string; cookieName?: string; expected: 'dark' | 'light' | null }>('readCookie', [
+    { name: 'reads dark theme from cookie',                cookieString: 'theme=dark',                         expected: 'dark' },
+    { name: 'reads light theme from cookie',               cookieString: 'theme=light',                        expected: 'light' },
+    { name: 'reads theme from middle of cookie string',    cookieString: 'other=value; theme=dark; more=stuff', expected: 'dark' },
+    { name: 'returns null for invalid theme value',        cookieString: 'theme=invalid',                      expected: null },
+    { name: 'returns null for empty theme value',          cookieString: 'theme=',                             expected: null },
+    { name: 'returns null when theme not in cookie',       cookieString: 'other=value',                        expected: null },
+    { name: 'returns null for empty cookie string',        cookieString: '',                                   expected: null },
+    { name: 'handles custom cookie name (found)',          cookieString: 'my-theme=dark',  cookieName: 'my-theme', expected: 'dark' },
+    { name: 'handles custom cookie name (not found)',      cookieString: 'theme=dark',     cookieName: 'my-theme', expected: null },
+  ], ({ cookieString, cookieName, expected }) => {
+    const manager = cookieName ? createThemeManager({ cookieName }) : createThemeManager()
+    expect(manager.readCookie(cookieString)).toBe(expected)
   })
 
-  describe('writeCookie', () => {
-    test('returns properly formatted cookie string', () => {
-      const manager = createThemeManager()
-
-      const cookie = manager.writeCookie('dark')
-      expect(cookie).toBe('theme=dark; Max-Age=31536000; Path=/; SameSite=Strict')
-    })
-
-    test('uses custom options in cookie string', () => {
-      const manager = createThemeManager({
-        cookieName: 'app-theme',
-        maxAge: 3600,
-        path: '/app',
-      })
-
-      const cookie = manager.writeCookie('light')
-      expect(cookie).toBe('app-theme=light; Max-Age=3600; Path=/app; SameSite=Strict')
-    })
+  // dprint-ignore
+  Test.suite<{ theme: 'dark' | 'light'; options?: { cookieName?: string; maxAge?: number; path?: string }; expected: string }>('writeCookie', [
+    { name: 'returns properly formatted cookie string',     theme: 'dark',  expected: 'theme=dark; Max-Age=31536000; Path=/; SameSite=Strict' },
+    { name: 'uses custom options in cookie string',        theme: 'light', options: { cookieName: 'app-theme', maxAge: 3600, path: '/app' }, expected: 'app-theme=light; Max-Age=3600; Path=/app; SameSite=Strict' },
+  ], ({ theme, options, expected }) => {
+    const manager = options ? createThemeManager(options) : createThemeManager()
+    expect(manager.writeCookie(theme)).toBe(expected)
   })
 
   describe('applyToDOM', () => {
@@ -129,39 +109,25 @@ describe('Theme', () => {
     })
   })
 
-  describe('getCurrentFromDOM', () => {
-    test('returns theme based on DOM classes', () => {
-      // @ts-expect-error - mocking document
-      global.document = mockDocument
-
-      const manager = createThemeManager()
-
-      mockDocument.documentElement.classList.contains.mockImplementation((className) => className === 'dark')
-      expect(manager.getCurrentFromDOM()).toBe('dark')
-
-      mockDocument.documentElement.classList.contains.mockImplementation((className) => className === 'light')
-      expect(manager.getCurrentFromDOM()).toBe('light')
-    })
-
-    test('returns null when no theme class present', () => {
-      // @ts-expect-error - mocking document
-      global.document = mockDocument
-
-      const manager = createThemeManager()
-
+  // dprint-ignore
+  Test.suite<{ mockClass?: string; classPrefix?: string; expected: 'dark' | 'light' | null }>('getCurrentFromDOM', [
+    { name: 'returns dark theme based on DOM class',       mockClass: 'dark',                          expected: 'dark' },
+    { name: 'returns light theme based on DOM class',      mockClass: 'light',                         expected: 'light' },
+    { name: 'returns null when no theme class present',                                                expected: null },
+    { name: 'handles custom class prefix',                 mockClass: 'theme-dark', classPrefix: 'theme-', expected: 'dark' },
+  ], ({ mockClass, classPrefix, expected }) => {
+    // @ts-expect-error - mocking document
+    global.document = mockDocument
+    
+    const manager = classPrefix ? createThemeManager({ classPrefix }) : createThemeManager()
+    
+    if (mockClass) {
+      mockDocument.documentElement.classList.contains.mockImplementation((className) => className === mockClass)
+    } else {
       mockDocument.documentElement.classList.contains.mockReturnValue(false)
-      expect(manager.getCurrentFromDOM()).toBe(null)
-    })
-
-    test('handles custom class prefix', () => {
-      // @ts-expect-error - mocking document
-      global.document = mockDocument
-
-      const manager = createThemeManager({ classPrefix: 'theme-' })
-
-      mockDocument.documentElement.classList.contains.mockImplementation((className) => className === 'theme-dark')
-      expect(manager.getCurrentFromDOM()).toBe('dark')
-    })
+    }
+    
+    expect(manager.getCurrentFromDOM()).toBe(expected)
   })
 
   // Toggle behavior is tested via integration tests with Playwright

package/src/lib/version/$$.ts

@@ -0,0 +1 @@
+export * from './version.js'

package/src/lib/version/$.test.ts

@@ -0,0 +1,101 @@
+import { Match } from 'effect'
+import { describe, expect, test } from 'vitest'
+import { Test } from '../../../tests/unit/helpers/test.js'
+import { DateOnly } from '../date-only/$.js'
+import { Semver } from '../semver/$.js'
+import { Version } from './$.js'
+
+describe('Version', () => {
+  // dprint-ignore
+  Test.suite<{ input: string; expectedTag: string; expectedString: string }>('decoding', [
+    { name: 'decodes semver strings as SemverVersion',                                                  input: '1.2.3',                                                                                    expectedTag: 'VersionSemver',  expectedString: '1.2.3' },
+    { name: 'decodes date strings as DateVersion',                                                      input: '2024-01-15',                                                                               expectedTag: 'VersionDate',    expectedString: '2024-01-15' },
+    { name: 'decodes other strings as CustomVersion',                                                   input: 'v1.0-beta',                                                                                expectedTag: 'VersionCustom',  expectedString: 'v1.0-beta' },
+    { name: 'prefers semver over date when ambiguous',                                                  input: '1.0.0',                                                                                    expectedTag: 'VersionSemver',  expectedString: '1.0.0' },
+  ], ({ input, expectedTag, expectedString }) => {
+    const version = Version.decodeSync(input)
+    expect(version._tag).toBe(expectedTag)
+    expect(Version.toString(version)).toBe(expectedString)
+  })
+
+  // dprint-ignore
+  Test.suite<{ v1: string; v2: string; expectedComparison: 'less' | 'greater' }>('ordering', [
+    { name: 'orders by type precedence: Semver > Date',                                                 v1: '1.0.0',                                                                                       v2: '2024-01-15',     expectedComparison: 'less' },
+    { name: 'orders by type precedence: Date > Custom',                                                 v1: '2024-01-15',                                                                                  v2: 'custom',         expectedComparison: 'less' },
+    { name: 'orders by type precedence: Semver > Custom',                                               v1: '1.0.0',                                                                                       v2: 'custom',         expectedComparison: 'less' },
+    { name: 'orders within semver type (1.0.0 < 2.0.0)',                                                v1: '1.0.0',                                                                                       v2: '2.0.0',          expectedComparison: 'less' },
+    { name: 'orders within semver type (2.0.0 > 1.0.0)',                                                v1: '2.0.0',                                                                                       v2: '1.0.0',          expectedComparison: 'greater' },
+    { name: 'orders within date type (2024-01-15 < 2024-02-15)',                                        v1: '2024-01-15',                                                                                  v2: '2024-02-15',     expectedComparison: 'less' },
+    { name: 'orders within date type (2024-02-15 > 2024-01-15)',                                        v1: '2024-02-15',                                                                                  v2: '2024-01-15',     expectedComparison: 'greater' },
+    { name: 'orders within custom type (alpha < beta)',                                                 v1: 'alpha',                                                                                       v2: 'beta',           expectedComparison: 'less' },
+    { name: 'orders within custom type (beta > alpha)',                                                 v1: 'beta',                                                                                        v2: 'alpha',          expectedComparison: 'greater' },
+  ], ({ v1, v2, expectedComparison }) => {
+    const version1 = Version.decodeSync(v1)
+    const version2 = Version.decodeSync(v2)
+    const result = Version.order(version1, version2)
+    
+    if (expectedComparison === 'less') {
+      expect(result).toBeLessThan(0)
+    } else {
+      expect(result).toBeGreaterThan(0)
+    }
+  })
+
+  // dprint-ignore
+  Test.suite<{ v1: string; v2: string; expected: boolean }>('equivalence', [
+    { name: 'considers same versions equal',                                                            v1: '1.0.0',                                                                                       v2: '1.0.0',          expected: true },
+    { name: 'considers different types unequal',                                                        v1: '1.0.0',                                                                                       v2: '2024-01-15',     expected: false },
+    { name: 'considers different values of same type unequal',                                          v1: '1.0.0',                                                                                       v2: '2.0.0',          expected: false },
+  ], ({ v1, v2, expected }) => {
+    const version1 = Version.decodeSync(v1)
+    const version2 = Version.decodeSync(v2)
+    expect(Version.equivalence(version1, version2)).toBe(expected)
+  })
+
+  // dprint-ignore
+  Test.suite<{ input: string; expected: string }>('pattern matching', [
+    { name: 'matches on integer version',                                                               input: '123',                                                                                       expected: 'Integer: 123' },
+    { name: 'matches on semver version',                                                                input: '1.2.3',                                                                                    expected: 'Semver: 1.2.3' },
+    { name: 'matches on date version',                                                                  input: '2024-01-15',                                                                               expected: 'Date: 2024-01-15' },
+    { name: 'matches on custom version',                                                                input: 'v1.0-beta',                                                                                expected: 'Custom: v1.0-beta' },
+  ], ({ input, expected }) => {
+    const version = Version.decodeSync(input)
+    const result = Match.value(version).pipe(
+      Match.tag('VersionInteger', (v) => `Integer: ${v.value}`),
+      Match.tag('VersionSemver', (v) => `Semver: ${v.value}`),
+      Match.tag('VersionDate', (v) => `Date: ${v.value}`),
+      Match.tag('VersionCustom', (v) => `Custom: ${v.value}`),
+      Match.exhaustive
+    )
+    expect(result).toBe(expected)
+  })
+
+  // dprint-ignore
+  Test.suite<{ type: 'semver' | 'date' | 'custom'; input: string; expectedTag: string; expectedString: string }>('importers', [
+    { name: 'creates from semver',         type: 'semver',  input: '1.2.3',        expectedTag: 'VersionSemver',  expectedString: '1.2.3' },
+    { name: 'creates from date',           type: 'date',    input: '2024-01-15',   expectedTag: 'VersionDate',    expectedString: '2024-01-15' },
+    { name: 'creates from custom string',  type: 'custom',  input: 'v1.0-beta',    expectedTag: 'VersionCustom',  expectedString: 'v1.0-beta' },
+  ], ({ type, input, expectedTag, expectedString }) => {
+    let version: Version.Version
+    
+    switch (type) {
+      case 'semver': {
+        const semver = Semver.decodeSync(input)
+        version = Version.fromSemver(semver)
+        break
+      }
+      case 'date': {
+        const dateOnly = DateOnly.decodeSync(input)
+        version = Version.fromDateOnly(dateOnly)
+        break
+      }
+      case 'custom': {
+        version = Version.fromCustom(input)
+        break
+      }
+    }
+    
+    expect(version._tag).toBe(expectedTag)
+    expect(Version.toString(version)).toBe(expectedString)
+  })
+})

package/src/lib/version/$.ts

@@ -0,0 +1 @@
+export * as Version from './$$.js'

package/src/lib/version/custom.ts

@@ -0,0 +1,46 @@
+import { S } from '#lib/kit-temp/effect'
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+export const Custom = S.TaggedStruct('VersionCustom', {
+  value: S.String,
+}).annotations({
+  identifier: 'Custom',
+  title: 'Custom',
+  description: 'A custom version string with arbitrary format',
+  adt: { name: 'Version' },
+})
+
+// ============================================================================
+// Type
+// ============================================================================
+
+export type Custom = S.Schema.Type<typeof Custom>
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+export const make = Custom.make
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(Custom)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(Custom)
+export const decodeSync = S.decodeSync(Custom)
+export const encode = S.encode(Custom)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(Custom)

package/src/lib/version/date.ts

@@ -0,0 +1,47 @@
+import { S } from '#lib/kit-temp/effect'
+import { DateOnly } from '../date-only/$.js'
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+export const Date = S.TaggedStruct('VersionDate', {
+  value: DateOnly.DateOnly,
+}).annotations({
+  identifier: 'Date',
+  title: 'Date',
+  description: 'A version represented as a date (YYYY-MM-DD)',
+  adt: { name: 'Version' },
+})
+
+// ============================================================================
+// Type
+// ============================================================================
+
+export type Date = S.Schema.Type<typeof Date>
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+export const make = Date.make
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(Date)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(Date)
+export const decodeSync = S.decodeSync(Date)
+export const encode = S.encode(Date)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(Date)

package/src/lib/version/integer.ts

@@ -0,0 +1,46 @@
+import { S } from '#lib/kit-temp/effect'
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+export const Integer = S.TaggedStruct('VersionInteger', {
+  value: S.Number,
+}).annotations({
+  identifier: 'Integer',
+  title: 'Integer',
+  description: 'An integer-based version number (e.g., 1, 2, 3)',
+  adt: { name: 'Version' },
+})
+
+// ============================================================================
+// Type
+// ============================================================================
+
+export type Integer = S.Schema.Type<typeof Integer>
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+export const make = Integer.make
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(Integer)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(Integer)
+export const decodeSync = S.decodeSync(Integer)
+export const encode = S.encode(Integer)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(Integer)

package/src/lib/version/semver.ts

@@ -0,0 +1,46 @@
+import { S } from '#lib/kit-temp/effect'
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+export const Semver = S.TaggedStruct('VersionSemver', {
+  value: S.String,
+}).annotations({
+  identifier: 'Semver',
+  title: 'Semver',
+  description: 'A semantic version following SemVer specification',
+  adt: { name: 'Version' },
+})
+
+// ============================================================================
+// Type
+// ============================================================================
+
+export type Semver = S.Schema.Type<typeof Semver>
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+export const make = Semver.make
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(Semver)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(Semver)
+export const decodeSync = S.decodeSync(Semver)
+export const encode = S.encode(Semver)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(Semver)