polen 0.10.0-next.9 → 0.10.0

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

@@ -0,0 +1,244 @@
+import { Path } from '@wollybeard/kit'
+
+/**
+ * Special key added to path objects to reference the directory itself
+ */
+export const DIR_KEY = `$` as const
+
+/**
+ * Input type for path maps - plain nested objects with string values
+ */
+export interface PathInput {
+  [key: string]: string | PathInput
+}
+
+/**
+ * Processed paths with $ properties added to directories
+ */
+export type ProcessedPaths<T> =
+  & {
+    [K in keyof T]: T[K] extends string ? string
+      : ProcessedPaths<T[K]> & { [DIR_KEY]: string }
+  }
+  & (T extends PathInput ? { [DIR_KEY]: string } : {})
+
+/**
+ * Path map containing only relative paths
+ */
+export type RelativePathMap<T extends PathInput = PathInput> = ProcessedPaths<T>
+
+/**
+ * Path map containing paths rooted at the PathMap's origin
+ */
+export type RootedPathMap<T extends PathInput = PathInput> = ProcessedPaths<T>
+
+/**
+ * Path map containing absolute paths
+ */
+export type AbsolutePathMap<T extends PathInput = PathInput> = ProcessedPaths<T>
+
+/**
+ * Combined path map with relative, rooted, and absolute variants
+ */
+export interface PathMap<T extends PathInput = PathInput> {
+  /**
+   * Paths relative to their parent directory
+   * @example
+   * paths.relative.template.server.app // 'app.ts'
+   */
+  relative: RelativePathMap<T>
+
+  /**
+   * Paths from the PathMap's root
+   * @example
+   * paths.rooted.template.server.app // 'template/server/app.ts'
+   */
+  rooted: RootedPathMap<T>
+
+  /**
+   * Absolute paths from the filesystem root
+   * @example
+   * paths.absolute.template.server.app // '/project/template/server/app.ts'
+   */
+  absolute: AbsolutePathMap<T>
+
+  /**
+   * The base path used for absolute paths
+   */
+  base: string
+}
+
+/**
+ * Create a path map from nested path definitions
+ *
+ * @param paths - Nested object structure defining paths
+ * @param base - Optional base path for absolute paths
+ * @returns RelativePathMap if no base provided, PathMap if base provided
+ *
+ * @example
+ * ```ts
+ * // Without base - returns RelativePathMap
+ * const paths = PathMap.create({
+ *   src: {
+ *     lib: {
+ *       utils: 'utils.ts'
+ *     }
+ *   }
+ * })
+ *
+ * // With base - returns PathMap with all variants
+ * const paths = PathMap.create({
+ *   src: {
+ *     lib: {
+ *       utils: 'utils.ts'
+ *     }
+ *   }
+ * }, '/project')
+ *
+ * paths.relative.src.lib.utils  // 'utils.ts'
+ * paths.rooted.src.lib.utils    // 'src/lib/utils.ts'
+ * paths.absolute.src.lib.utils  // '/project/src/lib/utils.ts'
+ * ```
+ */
+export function create<T extends PathInput>(paths: T): RelativePathMap<T>
+export function create<T extends PathInput>(paths: T, base: string): PathMap<T>
+export function create<T extends PathInput>(paths: T, base?: string): RelativePathMap<T> | PathMap<T> {
+  const relative = processRelativePaths(paths, [])
+
+  if (!base) {
+    return relative as RelativePathMap<T>
+  }
+
+  // Normalize base path - trim spaces, collapse multiple slashes, remove trailing
+  const trimmedBase = base.trim()
+  // Collapse multiple slashes to single, then remove trailing (unless it's just "/")
+  const collapsedBase = trimmedBase.replace(/\/+/g, `/`)
+  const normalizedBase = collapsedBase === `/` ? `/` : collapsedBase.replace(/\/$/, ``)
+
+  const rooted = processRootedPaths(paths, [])
+  const absolute = processAbsolutePaths(paths, normalizedBase, [])
+
+  return {
+    relative: relative as RelativePathMap<T>,
+    rooted: rooted as RootedPathMap<T>,
+    absolute: absolute as AbsolutePathMap<T>,
+    base: normalizedBase,
+  }
+}
+
+/**
+ * Create a new PathMap with a different base path
+ *
+ * @param pathMap - Existing PathMap or RelativePathMap
+ * @param base - New base path
+ * @returns New PathMap with updated absolute paths
+ *
+ * @example
+ * ```ts
+ * const dev = PathMap.create(paths, '/dev')
+ * const prod = PathMap.rebase(dev, '/prod')
+ *
+ * prod.absolute.src.lib.utils // '/prod/src/lib/utils.ts'
+ * ```
+ */
+export const rebase = <T extends PathInput>(
+  pathMap: PathMap<T> | RelativePathMap<T>,
+  base: string,
+): PathMap<T> => {
+  // Extract the input structure from the relative paths
+  const input = extractInput(pathMap)
+  return create(input, base) as PathMap<T>
+}
+
+// Helper to process paths for relative variant (local to parent)
+const processRelativePaths = (input: PathInput, currentPath: string[]): any => {
+  const result: any = {}
+
+  // Add $ property for directory (just the last segment)
+  if (currentPath.length > 0) {
+    result[DIR_KEY] = currentPath[currentPath.length - 1]
+  } else {
+    result[DIR_KEY] = `.`
+  }
+
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === `string`) {
+      result[key] = value
+    } else {
+      result[key] = processRelativePaths(value, [...currentPath, key])
+    }
+  }
+
+  return result
+}
+
+// Helper to process paths for rooted variant (from PathMap root)
+const processRootedPaths = (input: PathInput, currentPath: string[]): any => {
+  const result: any = {}
+
+  // Add $ property for directory (full path from root)
+  result[DIR_KEY] = currentPath.length > 0 ? currentPath.join(`/`) : `.`
+
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === `string`) {
+      // File: join current path with filename
+      result[key] = currentPath.length > 0
+        ? `${currentPath.join(`/`)}/${value}`
+        : value
+    } else {
+      result[key] = processRootedPaths(value, [...currentPath, key])
+    }
+  }
+
+  return result
+}
+
+// Helper to process paths for absolute variant
+const processAbsolutePaths = (input: PathInput, base: string, currentPath: string[]): any => {
+  const result: any = {}
+
+  // Normalize base to not end with slash unless it's root
+  const normalizedBase = base === `/` ? base : base.replace(/\/$/, ``)
+
+  // Add $ property for directory
+  const relativePath = currentPath.length > 0 ? currentPath.join(`/`) : ``
+  result[DIR_KEY] = relativePath ? Path.join(normalizedBase, relativePath) : normalizedBase
+
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === `string`) {
+      // File: join base + current path + filename
+      const fullPath = currentPath.length > 0
+        ? Path.join(normalizedBase, ...currentPath, value)
+        : Path.join(normalizedBase, value)
+      result[key] = fullPath
+    } else {
+      result[key] = processAbsolutePaths(value, normalizedBase, [...currentPath, key])
+    }
+  }
+
+  return result
+}
+
+// Helper to extract input structure from processed paths
+const extractInput = (pathMap: any): PathInput => {
+  const input: PathInput = {}
+
+  // Get the source - could be relative from PathMap or the whole thing for RelativePathMap
+  const source = `relative` in pathMap ? pathMap.relative : pathMap
+
+  function extract(processed: any, target: PathInput) {
+    for (const [key, value] of Object.entries(processed)) {
+      if (key === DIR_KEY) continue
+
+      if (typeof value === `string`) {
+        target[key] = value
+      } else {
+        target[key] = {}
+        extract(value, target[key])
+      }
+    }
+  }
+
+  extract(source, input)
+  return input
+}

package/src/lib/react-router-aid/get-paths-patterns.ts

@@ -41,7 +41,7 @@ export const _getPathsRecurse = (
     if (isIndexRoute(route)) {
       // Index route uses the parent's accumulated path.
       // If parentPath is empty (implying root), it should be ROOT_PATH
-      collectedPaths.add(parentPath || ROOT_PATH)
+      collectedPaths.add(parentPath ?? ROOT_PATH)
 
       continue
     }

package/src/lib/react-router-aid/index.ts

@@ -1 +1 @@
-export * as ReactRouterAid from './react-router-aid.ts'
+export * as ReactRouterAid from './react-router-aid.js'

package/src/lib/react-router-aid/react-router-aid.ts

@@ -1,7 +1,7 @@
 import type { ReactRouter } from '#dep/react-router/index'
 import type { Http } from '@wollybeard/kit'
 
-export * from './get-paths-patterns.ts'
+export * from './get-paths-patterns.js'
 
 export type RouteObject = RouteObjectIndex | RouteObjectNonIndex
 

package/src/lib/react-router-loader/react-router-loader.ts

@@ -1,13 +1,12 @@
 import type { Fn } from '@wollybeard/kit'
 import { useLoaderData as useLoaderDataRR, useRouteLoaderData as useRouteLoaderDataRR } from 'react-router'
-import { superjson } from '../../singletons/superjson.ts'
+import { superjson } from '../../singletons/superjson.js'
 
 type Loader = Fn.AnyAny
 
 export const createLoader = <loader extends Loader>(loader: loader): loader => {
   // @ts-expect-error
   return async (...args: any[]) => {
-    // eslint-disable-next-line
     const data = await loader(...args)
     const serialized: Serialized = {
       superjsonData: superjson.stringify(data),
@@ -23,14 +22,12 @@ interface Serialized {
 export const useLoaderData = <loader extends Loader>(routeTarget?: string): Awaited<
   ReturnType<loader>
 > => {
-  // eslint-disable-next-line
   const loaderData = (
     routeTarget
       ? useRouteLoaderDataRR(routeTarget)
       : useLoaderDataRR()
   ) as Serialized
 
-  // eslint-disable-next-line
   if (loaderData === undefined) {
     throw new Error(`No loader data returned from route ${routeTarget ?? `<direct>`}`)
   }

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

@@ -1 +1 @@
-export * as StackProcessor from './stack-processor.ts'
+export * as StackProcessor from './stack-processor.js'

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

@@ -8,7 +8,6 @@ export const until = (
   // @ts-expect-error
   return async (...args) => {
     for (const fn of fns) {
-      // eslint-disable-next-line
       const result: any = await fn(...args)
       if (predicate(result)) return result
     }

package/src/lib/superjson-codec/codecs/graphql-schema.ts

@@ -1,5 +1,5 @@
 import { Grafaid } from '#lib/grafaid/index'
-import { create } from '../codec.ts'
+import { create } from '../codec.js'
 
 export const GraphQLSchema = create({
   name: `GraphQLSchema`,

package/src/lib/superjson-codec/exports.ts

@@ -1,2 +1,2 @@
-export * from './codec.ts'
-export * from './codecs/graphql-schema.ts'
+export * from './codec.js'
+export * from './codecs/graphql-schema.js'

package/src/lib/superjson-codec/index.ts

@@ -1 +1 @@
-export * as SuperjsonCodecs from './exports.ts'
+export * as SuperjsonCodecs from './exports.js'

package/src/lib/task/$$.ts

@@ -1,2 +1,2 @@
-export * from './report.ts'
-export * from './task.ts'
+export * from './report.js'
+export * from './task.js'

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

@@ -1,6 +1,6 @@
 import * as fc from 'fast-check'
 import { describe, expect, test, vi } from 'vitest'
-import { Task } from './$.ts'
+import { Task } from './$.js'
 
 describe('create', () => {
   test('executes async function and captures timing', async () => {
@@ -28,7 +28,7 @@ describe('create', () => {
     const report = await failing(null)
 
     expect(report.execution.output).toBeInstanceOf(Error)
-    expect((report.execution.output as Error).message).toBe('Failed')
+    expect(report.execution.output.message).toBe('Failed')
   })
 })
 

package/src/lib/task/$.ts

@@ -1 +1 @@
-export * as Task from './$$.ts'
+export * as Task from './$$.js'

package/src/lib/task/report.ts

@@ -1,6 +1,6 @@
 import { Mask } from '#lib/mask'
 import { Err, Str } from '@wollybeard/kit'
-import type { Definition, MaskOptions } from './task.ts'
+import type { Definition, MaskOptions } from './task.js'
 
 export interface Report<$Input, $Output> {
   task: Definition<$Input, $Output>

package/src/lib/task/task.ts

@@ -1,6 +1,6 @@
 import type { Mask } from '#lib/mask'
-import type { Report } from './report.ts'
-import { exitWithReport } from './report.ts'
+import type { Report } from './report.js'
+import { exitWithReport } from './report.js'
 
 export interface Definition<$Input = any, $Output = any> {
   name: string
@@ -37,7 +37,7 @@ export const create = <$Input, $Output>(
   },
 ): Task<$Input, $Output> => {
   const definition: Definition<$Input, $Output> = {
-    name: options?.name ?? (fn.name || 'anonymous'),
+    name: options?.name ?? (fn.name || `anonymous`),
     mask: options?.mask,
   }
 

package/src/lib/theme/$.ts

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

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

@@ -0,0 +1,190 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest'
+import { createThemeManager } from './theme.js'
+
+// Mock document and window
+const mockDocument = {
+  cookie: '',
+  documentElement: {
+    classList: {
+      add: vi.fn(),
+      remove: vi.fn(),
+      contains: vi.fn(),
+    },
+    setAttribute: vi.fn(), // Keep this for the applyToDOM test
+  },
+}
+
+const mockWindow = {
+  matchMedia: vi.fn(),
+}
+
+beforeEach(() => {
+  vi.resetAllMocks()
+  mockDocument.cookie = ''
+  mockDocument.documentElement.classList.contains.mockReturnValue(false)
+  mockWindow.matchMedia.mockReturnValue({ matches: false })
+})
+
+describe('Theme', () => {
+  describe('createThemeManager', () => {
+    test('creates manager with default options', () => {
+      const manager = createThemeManager()
+      expect(manager).toHaveProperty('readCookie')
+      expect(manager).toHaveProperty('writeCookie')
+      expect(manager).toHaveProperty('toggle')
+    })
+
+    test('creates manager with custom options', () => {
+      const manager = createThemeManager({
+        cookieName: 'custom-theme',
+        classPrefix: 'app-',
+        maxAge: 3600,
+        path: '/app',
+      })
+      expect(manager).toBeDefined()
+    })
+  })
+
+  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
+    })
+  })
+
+  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')
+    })
+  })
+
+  describe('applyToDOM', () => {
+    test('adds theme class and removes other theme class', () => {
+      // @ts-expect-error - mocking document
+      global.document = mockDocument
+
+      const manager = createThemeManager()
+
+      manager.applyToDOM('dark')
+
+      expect(mockDocument.documentElement.classList.add).toHaveBeenCalledWith('dark')
+      expect(mockDocument.documentElement.classList.remove).toHaveBeenCalledWith('light')
+    })
+
+    test('handles custom class prefix', () => {
+      // @ts-expect-error - mocking document
+      global.document = mockDocument
+
+      const manager = createThemeManager({ classPrefix: 'app-' })
+
+      manager.applyToDOM('light')
+
+      expect(mockDocument.documentElement.classList.add).toHaveBeenCalledWith('app-light')
+      expect(mockDocument.documentElement.classList.remove).toHaveBeenCalledWith('app-dark')
+    })
+
+    test('does nothing when document is undefined', () => {
+      // @ts-expect-error - mocking undefined document
+      global.document = undefined
+
+      const manager = createThemeManager()
+
+      // Should not throw
+      expect(() => {
+        manager.applyToDOM('dark')
+      }).not.toThrow()
+    })
+  })
+
+  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()
+
+      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')
+    })
+  })
+
+  // Toggle behavior is tested via integration tests with Playwright
+  // as requested by the user to avoid complex DOM unit testing
+
+  describe('getCSS', () => {
+    test('returns CSS with default classes', () => {
+      const manager = createThemeManager()
+      const css = manager.getCSS()
+
+      expect(css).toContain('html.light')
+      expect(css).toContain('html.dark')
+      expect(css).toContain('@media (prefers-color-scheme: dark)')
+      expect(css).toContain('color-scheme: light')
+      expect(css).toContain('color-scheme: dark')
+    })
+
+    test('returns CSS with custom class prefix', () => {
+      const manager = createThemeManager({ classPrefix: 'app-' })
+      const css = manager.getCSS()
+
+      expect(css).toContain('html.app-light')
+      expect(css).toContain('html.app-dark')
+    })
+  })
+})