polen 0.11.0-next.2 → 0.11.0-next.21

package/src/lib/effect-glob/effect-glob.ts

@@ -0,0 +1,33 @@
+import { Effect } from 'effect'
+import * as TinyGlobby from 'tinyglobby'
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type GlobOptions = Omit<TinyGlobby.GlobOptions, 'patterns'>
+
+// ============================================================================
+// Functions
+// ============================================================================
+
+/**
+ * Effect-based wrapper for globbing file patterns.
+ * Returns an Effect that resolves to an array of matched file paths.
+ */
+export const glob = (
+  pattern: string | string[],
+  options?: GlobOptions,
+): Effect.Effect<string[], Error> => Effect.promise(() => TinyGlobby.glob(pattern, options))
+
+/**
+ * Synchronous Effect-based wrapper for globbing file patterns.
+ */
+export const globSync = (
+  pattern: string | string[],
+  options?: GlobOptions,
+): Effect.Effect<string[], Error> =>
+  Effect.try({
+    try: () => TinyGlobby.globSync(pattern, options),
+    catch: (error) => error instanceof Error ? error : new Error(String(error)),
+  })

package/src/lib/errors/$.ts

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

package/src/lib/file-path/$$.ts

@@ -0,0 +1,4 @@
+export * as Absolute from './absolute.js'
+export * from './file-path.js'
+export * as Relative from './relative.js'
+export * from './segment/$.js'

package/src/lib/file-path/$.test.ts

@@ -0,0 +1,45 @@
+import { expect, test } from 'vitest'
+import { FilePath } from './$.js'
+
+test.for([
+  { input: '/usr/local/bin', expected: '/usr/local/bin' },
+  { input: './src/index.ts', expected: './src/index.ts' },
+  { input: 'src/index.ts', expected: './src/index.ts' },
+  { input: '../package.json', expected: './../package.json' },
+])('encode/decode $input -> $expected', ({ input, expected }) => {
+  const decoded = FilePath.decodeSync(input)
+  const encoded = FilePath.encodeSync(decoded)
+  expect(encoded).toBe(expected)
+})
+
+test.for([
+  { path: '/usr/local/bin', isAbsolute: true },
+  { path: 'src/index.ts', isAbsolute: false },
+  { path: './src/index.ts', isAbsolute: false },
+  { path: '../package.json', isAbsolute: false },
+])('is absolute/relative $path', ({ path, isAbsolute }) => {
+  const fp = FilePath.decodeSync(path)
+  expect(FilePath.Absolute.is(fp)).toBe(isAbsolute)
+  expect(FilePath.Relative.is(fp)).toBe(!isAbsolute)
+})
+
+test.for([
+  { path: '/usr/local/bin', expectedSegments: ['usr', 'local', 'bin'] },
+  { path: 'src/index.ts', expectedSegments: ['src', 'index.ts'] },
+  { path: './src/index.ts', expectedSegments: ['src', 'index.ts'] },
+])('segments $path', ({ path, expectedSegments }) => {
+  const fp = FilePath.decodeSync(path)
+  expect(fp.segments.map(s => String(s))).toEqual(expectedSegments)
+})
+
+test('absolute path construction', () => {
+  const abs = FilePath.Absolute.make({ segments: ['usr', 'local', 'bin'].map(FilePath.Segment.make) })
+  const encoded = FilePath.Absolute.encodeSync(abs)
+  expect(encoded).toBe('/usr/local/bin')
+})
+
+test('relative path construction', () => {
+  const rel = FilePath.Relative.make({ segments: ['src', 'index.ts'].map(FilePath.Segment.make) })
+  const encoded = FilePath.Relative.encodeSync(rel)
+  expect(encoded).toBe('./src/index.ts')
+})

package/src/lib/file-path/$.ts

@@ -0,0 +1,5 @@
+// ============================================================================
+// File Path Namespace Export
+// ============================================================================
+
+export * as FilePath from './$$.js'

package/src/lib/file-path/absolute.ts

@@ -0,0 +1,66 @@
+import { S } from '#lib/kit-temp/effect'
+import { ParseResult } from 'effect'
+import { Segment } from './segment/$.js'
+const ENCODED_PREFIX = '/'
+
+// ============================================================================
+// Schema and Type
+// ============================================================================
+
+const AbsoluteDecoded = S.TaggedStruct('FilePathAbsolute', {
+  segments: S.Array(Segment.Segment),
+})
+
+const AbsoluteEncoded = S.String
+
+export const Absolute = S.transformOrFail(
+  AbsoluteEncoded,
+  AbsoluteDecoded,
+  {
+    strict: true,
+    encode: (absoluteFilePath) => {
+      return ParseResult.succeed(ENCODED_PREFIX + absoluteFilePath.segments.join(Segment.SEPARATOR))
+    },
+    decode: (input, options, ast) => {
+      if (!input.startsWith(ENCODED_PREFIX)) {
+        return ParseResult.fail(
+          new ParseResult.Type(ast, input, `Absolute paths must start with ${ENCODED_PREFIX}`),
+        )
+      }
+      input = input.slice(1) // Remove leading slash for splitting
+      const segments = input.split(Segment.SEPARATOR).map(s => Segment.make(s))
+      return ParseResult.succeed(AbsoluteDecoded.make({
+        segments,
+      }))
+    },
+  },
+)
+
+export type Absolute = typeof Absolute.Type
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+export const make = AbsoluteDecoded.make
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(Absolute)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(Absolute)
+export const decodeSync = S.decodeSync(Absolute)
+export const encode = S.encode(Absolute)
+export const encodeSync = S.encodeSync(Absolute)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(Absolute)

package/src/lib/file-path/file-path.ts

@@ -0,0 +1,34 @@
+import { S } from '#lib/kit-temp/effect'
+import { Absolute } from './absolute.js'
+import { Relative } from './relative.js'
+
+// ============================================================================
+// Schema and Type
+// ============================================================================
+
+export const FilePath = S.Union(
+  Absolute,
+  Relative,
+)
+  .annotations({
+    identifier: 'FilePath',
+    title: 'File Path',
+    description: 'A file path that can be either absolute or relative',
+  })
+
+export type FilePath = typeof FilePath.Type
+
+// ============================================================================
+// Type Guards
+// ============================================================================
+
+export const is = S.is(FilePath)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(FilePath)
+export const decodeSync = S.decodeSync(FilePath)
+export const encode = S.encode(FilePath)
+export const encodeSync = S.encodeSync(FilePath)

package/src/lib/file-path/relative.ts

@@ -0,0 +1,72 @@
+import { S } from '#lib/kit-temp/effect'
+import { ParseResult } from 'effect'
+import { Segment } from './segment/$.js'
+
+const ENCODED_PREFIX = './'
+
+// ============================================================================
+// Schema and Type
+// ============================================================================
+
+const Encoded = S.String
+
+const Decoded = S.TaggedStruct('FilePathRelative', {
+  segments: S.Array(Segment.Segment),
+})
+
+export const Relative = S.transformOrFail(
+  Encoded,
+  Decoded,
+  {
+    strict: true,
+    encode: (relativeFilePath) => {
+      return ParseResult.succeed(ENCODED_PREFIX + relativeFilePath.segments.join(Segment.SEPARATOR))
+    },
+    decode: (input, options, ast) => {
+      if (input.startsWith(Segment.SEPARATOR)) {
+        return ParseResult.fail(
+          new ParseResult.Type(ast, input, `Relative paths must not start with a leading slash: ${input}`),
+        )
+      }
+
+      // Strip ./ prefix for normalization
+      let normalizedInput = input
+      if (input.startsWith(ENCODED_PREFIX)) {
+        normalizedInput = input.slice(2)
+      }
+      const segments = normalizedInput.split(Segment.SEPARATOR).filter(s => s).map(s => Segment.make(s))
+      return ParseResult.succeed(Decoded.make({
+        segments,
+      }))
+    },
+  },
+)
+
+export type Relative = typeof Relative.Type
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+export const make = Decoded.make
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = S.is(Relative)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(Relative)
+export const decodeSync = S.decodeSync(Relative)
+export const encode = S.encode(Relative)
+export const encodeSync = S.encodeSync(Relative)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(Relative)

package/src/lib/file-path/segment/$.ts

@@ -0,0 +1 @@
+export * as Segment from './segment.js'

package/src/lib/file-path/segment/segment.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test } from 'vitest'
+import { Test } from '../../../../tests/unit/helpers/test.js'
+import * as FilePathSegment from './segment.js'
+
+describe('FilePathSegment', () => {
+  describe('SEPARATOR', () => {
+    test('should be forward slash', () => {
+      expect(FilePathSegment.SEPARATOR).toBe('/')
+    })
+  })
+  // dprint-ignore
+  Test.suite<{ segments: string[]; expected: string }>('join', [
+    { name: 'joins path segments',                                                                       segments: ['foo', 'bar', 'baz.txt'],                                                               expected: 'foo/bar/baz.txt' },
+    { name: 'handles leading slashes',                                                                   segments: ['/foo', '/bar', '/baz.txt'],                                                            expected: '/foo/bar/baz.txt' },
+    { name: 'handles trailing slashes',                                                                  segments: ['foo/', 'bar/', 'baz.txt'],                                                             expected: 'foo/bar/baz.txt' },
+    { name: 'handles empty segments',                                                                    segments: ['foo', '', 'bar', '', 'baz.txt'],                                                       expected: 'foo/bar/baz.txt' },
+    { name: 'returns empty for no segments',                                                             segments: [],                                                                                      expected: '' },
+  ], ({ segments, expected }) => {
+    const path = FilePathSegment.join(...segments.map(FilePathSegment.make))
+    expect(path).toBe(expected)
+  })
+
+  // dprint-ignore
+  Test.suite<{ path: string; extension: string; expected: string }>('upsertExtension', [
+    { name: 'adds extension when missing',                                                               path: 'file',                                                                                      extension: 'json',  expected: 'file.json' },
+    { name: 'replaces existing extension',                                                               path: 'file.txt',                                                                                  extension: 'json',  expected: 'file.json' },
+    { name: 'handles extension with dot',                                                                path: 'file',                                                                                      extension: '.json', expected: 'file.json' },
+    { name: 'handles multiple dots in filename',                                                         path: 'file.test.txt',                                                                             extension: 'json',  expected: 'file.test.json' },
+    { name: 'handles paths with directories',                                                            path: '/path/to/file.txt',                                                                         extension: 'json',  expected: '/path/to/file.json' },
+  ], ({ path, extension, expected }) => {
+    const result = FilePathSegment.upsertExtension(FilePathSegment.make(path), extension)
+    expect(result).toBe(expected)
+  })
+
+  // dprint-ignore
+  Test.suite<{ path: string; extension: string; expected: string }>('withExtension', [
+    { name: 'adds extension without dot',                                                                path: 'file',                                                                                      extension: 'json',  expected: 'file.json' },
+    { name: 'adds extension with dot',                                                                  path: 'file',                                                                                      extension: '.json', expected: 'file.json' },
+  ], ({ path, extension, expected }) => {
+    const result = FilePathSegment.ensureExtension(FilePathSegment.make(path), extension)
+    expect(result).toBe(expected)
+  })
+
+  // dprint-ignore
+  Test.suite<{ path: string; expected: string }>('withoutExtension', [
+    { name: 'removes extension',                                                                         path: 'file.json',                                                                                 expected: 'file' },
+    { name: 'handles no extension',                                                                      path: 'file',                                                                                      expected: 'file' },
+  ], ({ path, expected }) => {
+    const result = FilePathSegment.withoutExtension(FilePathSegment.make(path))
+    expect(result).toBe(expected)
+  })
+
+  // dprint-ignore
+  Test.suite<{ path: string; expected: string | undefined }>('getExtension', [
+    { name: 'gets extension',                                                                            path: 'file.json',                                                                                 expected: 'json' },
+    { name: 'returns undefined for no extension',                                                        path: 'file',                                                                                      expected: undefined },
+  ], ({ path, expected }) => {
+    const result = FilePathSegment.getExtension(FilePathSegment.make(path))
+    expect(result).toBe(expected)
+  })
+
+  // dprint-ignore
+  Test.suite<{ path: string; expected: string }>('getFileName', [
+    { name: 'gets filename from path',                                                                   path: '/path/to/file.json',                                                                        expected: 'file.json' },
+    { name: 'handles Windows paths',                                                                     path: 'C:/path/to/file.json',                                                                      expected: 'file.json' },
+    { name: 'returns full path if no directory',                                                         path: 'file.json',                                                                                 expected: 'file.json' },
+  ], ({ path, expected }) => {
+    const result = FilePathSegment.getFileName(FilePathSegment.make(path))
+    expect(result).toBe(expected)
+  })
+
+  // dprint-ignore
+  Test.suite<{ path: string; expected: string }>('getDirectory', [
+    { name: 'gets directory from path',                                                                  path: '/path/to/file.json',                                                                        expected: '/path/to' },
+    { name: 'returns dot for no directory',                                                              path: 'file.json',                                                                                 expected: '.' },
+  ], ({ path, expected }) => {
+    const result = FilePathSegment.getDirectory(FilePathSegment.make(path))
+    expect(result).toBe(expected)
+  })
+})

package/src/lib/file-path/segment/segment.ts

@@ -0,0 +1,134 @@
+import { S } from '#lib/kit-temp/effect'
+import { Brand } from 'effect'
+import * as Path from 'node:path'
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+export const SEPARATOR = '/' as const
+
+// ============================================================================
+// Schema and Type
+// ============================================================================
+
+/**
+ * File path segment
+ */
+export type Segment = string & Brand.Brand<'FilePathSegment'>
+export const Segment = S.String.pipe(
+  S.brand('FilePathSegment'),
+  S.annotations({
+    identifier: 'FilePathSegment',
+    description: 'A segment of a file path',
+  }),
+)
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+export const make = (path: string): Segment => path as Segment
+
+// ============================================================================
+// Type Guard
+// ============================================================================
+
+export const is = (value: unknown): value is Segment => typeof value === 'string'
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(Segment)
+export const decodeSync = S.decodeSync(Segment)
+export const encode = S.encode(Segment)
+
+// ============================================================================
+// Domain Logic
+// ============================================================================
+
+/**
+ * Add extension to a file path
+ */
+export const ensureExtension = (
+  path: Segment,
+  extension: string,
+): Segment => {
+  const ext = extension.startsWith('.') ? extension : `.${extension}`
+  return `${path}${ext}` as Segment
+}
+
+/**
+ * Remove extension from a file path
+ */
+export const withoutExtension = (path: Segment): Segment => {
+  const dir = Path.dirname(path)
+  const base = Path.basename(path, Path.extname(path))
+  return join(
+    dir as Segment,
+    base as Segment,
+  )
+}
+
+/**
+ * Get the extension from a file path
+ */
+export const getExtension = (path: Segment): string | undefined => {
+  const ext = Path.extname(path)
+  // Remove the leading dot if present
+  return ext ? ext.slice(1) : undefined
+}
+
+/**
+ * Get the file name from a path
+ */
+export const getFileName = (path: Segment): string => {
+  return Path.basename(path)
+}
+
+/**
+ * Get the directory from a path
+ */
+export const getDirectory = (path: Segment): Segment => {
+  const dir = Path.dirname(path)
+  // Normalize to forward slashes
+  return dir.replace(/\\/g, SEPARATOR) as Segment
+}
+
+/**
+ * Join multiple path segments together
+ * Uses node:path internally for proper path handling
+ */
+export const join = (...segments: ReadonlyArray<Segment>): Segment => {
+  if (segments.length === 0) {
+    return '' as Segment
+  }
+
+  // Use Path.join for consistent path handling
+  const joined = Path.join(...segments)
+
+  // Normalize to forward slashes
+  return joined.replace(/\\/g, SEPARATOR) as Segment
+}
+
+/**
+ * Upsert extension - adds extension if missing, replaces if present
+ * @param path - The file path
+ * @param extension - The extension to upsert (with or without leading dot)
+ */
+export const upsertExtension = (
+  path: Segment,
+  extension: string,
+): Segment => {
+  const ext = extension.startsWith('.') ? extension : `.${extension}`
+  const currentExt = getExtension(path)
+
+  if (currentExt) {
+    // Replace existing extension
+    return ensureExtension(withoutExtension(path), extension)
+  } else {
+    // Add extension
+    return ensureExtension(path, extension)
+  }
+}

package/src/lib/file-router/$.ts

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

package/src/lib/file-router/index.test.ts

@@ -1,7 +1,8 @@
 import { Fn } from '@wollybeard/kit'
+import { Effect } from 'effect'
 import { describe, expect } from 'vitest'
-import { test } from '../../../tests/unit/helpers/test.js'
-import { FileRouter } from './index.js'
+import { test } from '../../../tests/unit/helpers/test-with-fixtures.js'
+import { FileRouter } from './$.js'
 
 /* Note
 
@@ -12,7 +13,7 @@ absolute: { dir: expect.stringMatching(/^pages\/$/) },
 */
 
 const $ = Fn.$identityPartial<FileRouter.ScanResult> // subset data factory
-const scan = (path: string) => FileRouter.scan({ dir: path + '/pages' })
+const scan = (path: string) => Effect.runPromise(FileRouter.scan({ dir: path + '/pages' }))
 
 describe('.scan', () => {
   describe('literal', () => {