polen 0.11.0-next.15 → 0.11.0-next.16

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/file-path/$$.ts

@@ -1,5 +1,4 @@
-// ============================================================================
-// File Path Module Exports
-// ============================================================================
-
+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

@@ -2,4 +2,4 @@
 // File Path Namespace Export
 // ============================================================================
 
-export * as FilePathSegment from './$$.js'
+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

@@ -1,134 +1,34 @@
 import { S } from '#lib/kit-temp/effect'
-import { Brand } from 'effect'
-import * as Path from 'node:path'
-
-// ============================================================================
-// Constants
-// ============================================================================
-
-export const SEPARATOR = '/' as const
+import { Absolute } from './absolute.js'
+import { Relative } from './relative.js'
 
 // ============================================================================
 // Schema and Type
 // ============================================================================
 
-/**
- * File path segment
- */
-export type FilePathSegment = string & Brand.Brand<'FilePathSegment'>
-export const FilePathSegment = S.String.pipe(
-  S.brand('FilePathSegment'),
-  S.annotations({
-    identifier: 'FilePathSegment',
-    description: 'A segment of a file path',
-  }),
+export const FilePath = S.Union(
+  Absolute,
+  Relative,
 )
+  .annotations({
+    identifier: 'FilePath',
+    title: 'File Path',
+    description: 'A file path that can be either absolute or relative',
+  })
 
-// ============================================================================
-// Constructors
-// ============================================================================
-
-export const make = (path: string): FilePathSegment => path as FilePathSegment
+export type FilePath = typeof FilePath.Type
 
 // ============================================================================
-// Type Guard
+// Type Guards
 // ============================================================================
 
-export const is = (value: unknown): value is FilePathSegment => typeof value === 'string'
+export const is = S.is(FilePath)
 
 // ============================================================================
 // Codec
 // ============================================================================
 
-export const decode = S.decode(FilePathSegment)
-export const decodeSync = S.decodeSync(FilePathSegment)
-export const encode = S.encode(FilePathSegment)
-
-// ============================================================================
-// Domain Logic
-// ============================================================================
-
-/**
- * Add extension to a file path
- */
-export const ensureExtension = (
-  path: FilePathSegment,
-  extension: string,
-): FilePathSegment => {
-  const ext = extension.startsWith('.') ? extension : `.${extension}`
-  return `${path}${ext}` as FilePathSegment
-}
-
-/**
- * Remove extension from a file path
- */
-export const withoutExtension = (path: FilePathSegment): FilePathSegment => {
-  const dir = Path.dirname(path)
-  const base = Path.basename(path, Path.extname(path))
-  return join(
-    dir as FilePathSegment,
-    base as FilePathSegment,
-  )
-}
-
-/**
- * Get the extension from a file path
- */
-export const getExtension = (path: FilePathSegment): 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: FilePathSegment): string => {
-  return Path.basename(path)
-}
-
-/**
- * Get the directory from a path
- */
-export const getDirectory = (path: FilePathSegment): FilePathSegment => {
-  const dir = Path.dirname(path)
-  // Normalize to forward slashes
-  return dir.replace(/\\/g, SEPARATOR) as FilePathSegment
-}
-
-/**
- * Join multiple path segments together
- * Uses node:path internally for proper path handling
- */
-export const join = (...segments: ReadonlyArray<FilePathSegment>): FilePathSegment => {
-  if (segments.length === 0) {
-    return '' as FilePathSegment
-  }
-
-  // Use Path.join for consistent path handling
-  const joined = Path.join(...segments)
-
-  // Normalize to forward slashes
-  return joined.replace(/\\/g, SEPARATOR) as FilePathSegment
-}
-
-/**
- * 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: FilePathSegment,
-  extension: string,
-): FilePathSegment => {
-  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)
-  }
-}
+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/{file-path.test.ts → segment/segment.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest'
-import { Test } from '../../../tests/unit/helpers/test.js'
-import * as FilePathSegment from './$$.js'
+import { Test } from '../../../../tests/unit/helpers/test.js'
+import * as FilePathSegment from './segment.js'
 
 describe('FilePathSegment', () => {
   describe('SEPARATOR', () => {

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)
+  }
+}