polen 0.11.0-next.14 → 0.11.0-next.16

package/src/lib/services-crud/browser-ro.ts

@@ -0,0 +1,98 @@
+import { Data, Effect, Layer } from 'effect'
+import { CrudService } from './service.js'
+
+/**
+ * Structured error types for browser read-only operations
+ */
+export class FetchError extends Data.TaggedError('FetchError')<{
+  readonly url: string
+  readonly status: number
+  readonly statusText: string
+}> {}
+
+export class NetworkError extends Data.TaggedError('NetworkError')<{
+  readonly relativePath: string
+  readonly cause: unknown
+}> {}
+
+export class UnsupportedOperationError extends Data.TaggedError('UnsupportedOperationError')<{
+  readonly operation: string
+  readonly message: string
+}> {}
+
+/**
+ * Create a read-only CRUD service layer for browser environments.
+ *
+ * This service uses the fetch API to read files from a remote server.
+ * Write, list, and remove operations are not supported and will fail
+ * with descriptive error messages.
+ *
+ * This is ideal for:
+ * - Loading static data from a CDN or static server
+ * - Reading configuration files in browser applications
+ * - Fetching pre-generated data exports
+ *
+ * For write operations in browser environments, implement a custom
+ * service that uses your API endpoints.
+ *
+ * @param baseUrl - Base URL for all fetch operations
+ * @returns Layer providing read-only CrudService backed by HTTP fetch
+ */
+export const browserReadOnly = (baseUrl: string) => {
+  const normalizedBaseUrl = baseUrl.endsWith('/') ? baseUrl : baseUrl + '/'
+
+  return Layer.succeed(CrudService, {
+    read: (relativePath: string) =>
+      Effect.gen(function*() {
+        const url = new URL(relativePath, normalizedBaseUrl).toString()
+
+        const response = yield* Effect.tryPromise({
+          try: () => fetch(url),
+          catch: (cause) => new NetworkError({ relativePath, cause }),
+        })
+
+        if (!response.ok) {
+          return yield* Effect.fail(
+            new FetchError({
+              url,
+              status: response.status,
+              statusText: response.statusText,
+            }),
+          )
+        }
+
+        return yield* Effect.tryPromise({
+          try: () => response.text(),
+          catch: (cause) => new NetworkError({ relativePath, cause }),
+        })
+      }),
+
+    write: (_relativePath: string, _data: string) =>
+      Effect.fail(
+        new UnsupportedOperationError({
+          operation: 'write',
+          message: 'Write operations not supported by Browser Read-Only service. '
+            + 'Use a server-side CRUD service or implement a custom browser service for your API.',
+        }),
+      ),
+
+    list: (_relativePath: string) =>
+      Effect.fail(
+        new UnsupportedOperationError({
+          operation: 'list',
+          message: 'List operations not supported by Browser Read-Only service. '
+            + 'Browser environments cannot list remote directories. '
+            + 'Consider using a manifest file or selection-based loading.',
+        }),
+      ),
+
+    remove: (_relativePath: string) =>
+      Effect.fail(
+        new UnsupportedOperationError({
+          operation: 'remove',
+          message: 'Remove operations not supported by Browser Read-Only service. '
+            + 'Use a server-side CRUD service or implement a custom browser service for your API.',
+        }),
+      ),
+  })
+}

package/src/lib/services-crud/filesystem.ts

@@ -0,0 +1,63 @@
+import { FileSystem, Path } from '@effect/platform'
+import { NodeFileSystem, NodePath } from '@effect/platform-node'
+import { Effect, Layer } from 'effect'
+import { CrudService } from './service.js'
+
+/**
+ * Create a CRUD service layer that adapts Effect Platform FileSystem service.
+ *
+ * This adapter bridges the gap between the generic CRUD service interface and
+ * the rich FileSystem service from Effect Platform. It handles:
+ * - Auto-creation of parent directories on write
+ * - Path resolution relative to the base path
+ * - Error mapping from PlatformError to generic Error
+ * - Graceful handling of missing files/directories
+ *
+ * @param basePath - Base directory path for all operations
+ * @returns Layer providing CrudService backed by FileSystem
+ */
+export const fromFileSystem = (basePath: string) =>
+  Layer.effect(
+    CrudService,
+    Effect.gen(function*() {
+      const fs = yield* FileSystem.FileSystem
+      const path = yield* Path.Path
+
+      return {
+        read: (relativePath: string) =>
+          fs.readFileString(path.join(basePath, relativePath))
+            .pipe(Effect.mapError(error => new Error(`Failed to read ${relativePath}: ${error}`))),
+
+        write: (relativePath: string, data: string) =>
+          Effect.gen(function*() {
+            const fullPath = path.join(basePath, relativePath)
+            const dir = path.dirname(fullPath)
+            yield* fs.makeDirectory(dir, { recursive: true })
+            yield* fs.writeFileString(fullPath, data)
+          }).pipe(Effect.mapError(error => new Error(`Failed to write ${relativePath}: ${error}`))),
+
+        list: (relativePath: string) =>
+          fs.readDirectory(path.join(basePath, relativePath))
+            .pipe(
+              Effect.catchTag(
+                'SystemError',
+                error => error.reason === 'NotFound' ? Effect.succeed([]) : Effect.fail(error),
+              ),
+              Effect.mapError(error => new Error(`Failed to list ${relativePath}: ${error}`)),
+            ),
+
+        remove: (relativePath: string) =>
+          fs.remove(path.join(basePath, relativePath))
+            .pipe(
+              Effect.catchTag(
+                'SystemError',
+                error => error.reason === 'NotFound' ? Effect.succeed(undefined) : Effect.fail(error),
+              ),
+              Effect.mapError(error => new Error(`Failed to remove ${relativePath}: ${error}`)),
+            ),
+      }
+    }),
+  ).pipe(
+    Layer.provide(NodeFileSystem.layer),
+    Layer.provide(NodePath.layer),
+  )

package/src/lib/services-crud/memory.ts

@@ -0,0 +1,86 @@
+import { Effect, Layer } from 'effect'
+import * as path from 'node:path'
+import { CrudService } from './service.js'
+
+/**
+ * Options for configuring the memory CRUD service.
+ */
+export interface MemoryOptions {
+  /**
+   * Base path for all operations (defaults to '.')
+   */
+  basePath?: string
+
+  /**
+   * Initial files to populate the memory filesystem
+   */
+  initialFiles?: Map<string, string> | Record<string, string>
+}
+
+/**
+ * Create a CRUD service layer backed by in-memory storage.
+ *
+ * This service stores all data in memory using a Map, making it perfect for:
+ * - Unit testing with isolated, predictable state
+ * - Temporary data storage that doesn't need persistence
+ * - Fast operations without disk I/O overhead
+ *
+ * The service maintains proper path semantics and directory structure
+ * simulation while keeping everything in memory.
+ *
+ * @param options - Configuration options
+ * @returns Layer providing CrudService backed by memory storage
+ */
+export const memory = (options?: MemoryOptions) => {
+  const basePath = options?.basePath || '.'
+  const initialFilesInput = options?.initialFiles instanceof Map
+    ? options.initialFiles
+    : new Map(Object.entries(options?.initialFiles || {}))
+
+  // Convert initial files to use full paths and create persistent storage
+  const files = new Map<string, string>()
+  for (const [filename, content] of initialFilesInput) {
+    const fullPath = path.join(basePath, filename)
+    files.set(fullPath, content)
+  }
+
+  return Layer.succeed(CrudService, {
+    read: (relativePath: string) =>
+      Effect.sync(() => {
+        const fullPath = path.join(basePath, relativePath)
+        const content = files.get(fullPath)
+        if (content === undefined) {
+          throw new Error(`File not found: ${relativePath}`)
+        }
+        return content
+      }),
+
+    write: (relativePath: string, data: string) =>
+      Effect.sync(() => {
+        const fullPath = path.join(basePath, relativePath)
+        files.set(fullPath, data)
+      }),
+
+    list: (relativePath: string) =>
+      Effect.sync(() => {
+        const searchPath = path.join(basePath, relativePath)
+        const normalizedSearchPath = searchPath.endsWith('/') ? searchPath : searchPath + '/'
+
+        // Find all files in the directory
+        return Array.from(files.keys())
+          .filter(filePath => {
+            const dir = path.dirname(filePath)
+            const normalizedDir = dir.endsWith('/') ? dir : dir + '/'
+            return normalizedDir === normalizedSearchPath
+              || (searchPath === basePath && dir === searchPath)
+          })
+          .map(filePath => path.basename(filePath))
+      }),
+
+    remove: (relativePath: string) =>
+      Effect.sync(() => {
+        const fullPath = path.join(basePath, relativePath)
+        files.delete(fullPath)
+      }),
+  })
+}

package/src/lib/services-crud/service.ts

@@ -0,0 +1,49 @@
+import { Context, Effect } from 'effect'
+
+/**
+ * Core CRUD service interface for basic file operations.
+ *
+ * This interface provides platform-agnostic CRUD operations for string-based file content.
+ * Implementations can target different platforms (filesystem, memory, HTTP, etc.) while
+ * maintaining the same interface contract.
+ */
+export interface CrudService {
+  /**
+   * Read file contents as a string.
+   *
+   * @param path - Relative path to the file
+   * @returns Effect resolving to file contents as string
+   */
+  readonly read: (path: string) => Effect.Effect<string, Error>
+
+  /**
+   * Write string data to a file.
+   * Implementations should auto-create parent directories as needed.
+   *
+   * @param path - Relative path to the file
+   * @param data - String content to write
+   * @returns Effect resolving when write is complete
+   */
+  readonly write: (path: string, data: string) => Effect.Effect<void, Error>
+
+  /**
+   * List contents of a directory.
+   *
+   * @param path - Relative path to the directory
+   * @returns Effect resolving to array of filenames in the directory
+   */
+  readonly list: (path: string) => Effect.Effect<readonly string[], Error>
+
+  /**
+   * Remove a file or directory.
+   *
+   * @param path - Relative path to the file or directory to remove
+   * @returns Effect resolving when removal is complete
+   */
+  readonly remove: (path: string) => Effect.Effect<void, Error>
+}
+
+/**
+ * Service tag for dependency injection.
+ */
+export const CrudService = Context.GenericTag<CrudService>('@polen/services-crud/CrudService')

package/src/lib/stack-processor/stack-processor.ts

@@ -1,6 +1,29 @@
 import type { Bool, Fn, Prom } from '@wollybeard/kit'
 import { Undefined } from '@wollybeard/kit'
+import { Effect } from 'effect'
 
+/**
+ * Effect-based version that processes functions sequentially until predicate is met
+ */
+export const untilEffect = <A extends readonly unknown[], R, E, Context>(
+  predicate: (value: R) => boolean,
+) =>
+<fns extends readonly ((..._: A) => Effect.Effect<R, E, Context>)[]>(
+  fns: fns,
+) =>
+(...args: A): Effect.Effect<R | undefined, E, Context> =>
+  Effect.gen(function*() {
+    for (const fn of fns) {
+      const result = yield* fn(...args)
+      if (predicate(result)) return result
+    }
+    return undefined
+  })
+
+/**
+ * Legacy Promise-based version for backward compatibility
+ * @deprecated Use untilEffect for better error handling and composition
+ */
 export const until = (
   predicate: Bool.Predicate,
 ) =>
@@ -15,4 +38,13 @@ export const until = (
   }
 }
 
+/**
+ * Effect-based version that processes functions until a defined result is found
+ */
+export const untilDefinedEffect = untilEffect(Undefined.isnt)
+
+/**
+ * Legacy Promise-based version for backward compatibility
+ * @deprecated Use untilDefinedEffect
+ */
 export const untilDefined = until(Undefined.isnt)

package/src/lib/swiss/$$.ts

@@ -0,0 +1,5 @@
+// Barrel export - all public APIs
+export { Grid } from './grid.js'
+export { Body, Extended, Item, Viewport } from './items.js'
+export { SubGrid } from './subgrid.js'
+export * from './types.js'

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

@@ -0,0 +1,89 @@
+import { describe, expect, test } from 'vitest'
+import { extractSpacingProps } from './utils.js'
+
+describe('Swiss Grid Radix Props Integration', () => {
+  test('extractSpacingProps handles margin props', () => {
+    const props = {
+      mt: '4',
+      mb: '2',
+      mx: { initial: '3', md: '5' },
+      otherProp: 'value',
+    }
+
+    const result = extractSpacingProps(props)
+
+    // Should have className and style properties
+    expect(result).toHaveProperty('className')
+    expect(result).toHaveProperty('style')
+
+    // Should not have the margin props in the result
+    expect(result).not.toHaveProperty('mt')
+    expect(result).not.toHaveProperty('mb')
+    expect(result).not.toHaveProperty('mx')
+
+    // Should preserve other props
+    expect(result.otherProp).toBe('value')
+  })
+
+  test('extractSpacingProps handles padding props', () => {
+    const props = {
+      p: '6',
+      py: { xs: '2', lg: '8' },
+      pl: '9',
+      customProp: 'test',
+    }
+
+    const result = extractSpacingProps(props)
+
+    // Should have className and style properties
+    expect(result).toHaveProperty('className')
+    expect(result).toHaveProperty('style')
+
+    // Should not have the padding props in the result
+    expect(result).not.toHaveProperty('p')
+    expect(result).not.toHaveProperty('py')
+    expect(result).not.toHaveProperty('pl')
+
+    // Should preserve other props
+    expect(result.customProp).toBe('test')
+  })
+
+  test('extractSpacingProps handles both margin and padding props', () => {
+    const props = {
+      m: '4',
+      p: { initial: '2', md: '4' },
+      mt: '-2',
+      className: 'custom-class',
+      style: { color: 'red' },
+    }
+
+    const result = extractSpacingProps(props)
+
+    // Should have className and style properties
+    expect(result).toHaveProperty('className')
+    expect(result).toHaveProperty('style')
+
+    // className should include custom class if provided
+    if (result.className) {
+      expect(result.className).toContain('custom-class')
+    }
+
+    // style should be merged if provided
+    if (result.style && typeof result.style === 'object') {
+      expect(result.style).toHaveProperty('color', 'red')
+    }
+
+    // Should not have the spacing props in the result
+    expect(result).not.toHaveProperty('m')
+    expect(result).not.toHaveProperty('p')
+    expect(result).not.toHaveProperty('mt')
+  })
+
+  test('extractSpacingProps handles empty props', () => {
+    const props = {}
+    const result = extractSpacingProps(props)
+
+    expect(result).toBeDefined()
+    // May or may not have className/style, but should not throw
+  })
+})

package/src/lib/swiss/$.ts

@@ -0,0 +1,2 @@
+// Namespace export - Swiss
+export * as Swiss from './$$.js'

package/src/lib/swiss/grid.tsx

@@ -0,0 +1,61 @@
+import * as React from 'react'
+import type { GridProps } from './types.js'
+import { cx, extractLayoutProps, generateCSSVars } from './utils.js'
+
+/**
+ * Swiss Grid container component.
+ *
+ * Creates a 12-column grid with semantic zones for content placement.
+ * Integrates with Radix UI Themes space scale for consistent spacing.
+ *
+ * @example
+ * ```tsx
+ * <Grid maxWidth={1440} gutter="var(--space-4)">
+ *   {children}
+ * </Grid>
+ * ```
+ */
+export const Grid = React.forwardRef<HTMLDivElement, GridProps>(
+  (
+    {
+      children,
+      maxWidth = 1440,
+      gutter,
+      margins,
+      columns = 12,
+      debug = false,
+      className: userClassName,
+      style: userStyle,
+      ...props
+    },
+    ref,
+  ) => {
+    // Extract Radix layout props (margin, padding, position, etc.)
+    const { className: layoutClassName, style: layoutStyle, ...restProps } = extractLayoutProps(props)
+
+    // Generate CSS variables from props
+    const cssVars = React.useMemo(
+      () =>
+        generateCSSVars({
+          maxWidth,
+          ...(gutter !== undefined && { gutter }),
+          ...(margins !== undefined && { margins }),
+          columns,
+        }),
+      [maxWidth, gutter, margins, columns],
+    )
+
+    return (
+      <div
+        ref={ref}
+        className={cx('swiss-grid', debug && 'swiss-grid--debug', layoutClassName, userClassName)}
+        style={{ ...cssVars, ...layoutStyle, ...userStyle }}
+        {...restProps}
+      >
+        {children}
+      </div>
+    )
+  },
+)
+
+Grid.displayName = 'Swiss.Grid'