polen 0.10.0-next.9 → 0.11.0-next.1

package/src/lib/mask/mask.test-d.ts

@@ -1,6 +1,6 @@
 import { Ts } from '@wollybeard/kit'
-import { Mask } from './$.ts'
-import type { InferOptions, Mask as MaskType, PropertiesMask } from './mask.ts'
+import { Mask } from './$.js'
+import type { InferOptions, Mask as MaskType, PropertiesMask } from './mask.js'
 
 // Test 1: InferOptions with unknown should accept all option types
 {
@@ -12,7 +12,7 @@ import type { InferOptions, Mask as MaskType, PropertiesMask } from './mask.ts'
   // All of these should be valid options
   const option1: Options = true
   const option2: Options = false
-  const option3: Options = ['name', 'age']
+  const option3: Options = [`name`, `age`]
   const option4: Options = []
   const option5: Options = { name: true, age: false }
   const option6: Options = {}
@@ -28,9 +28,9 @@ import type { InferOptions, Mask as MaskType, PropertiesMask } from './mask.ts'
   Ts.assertEqual<MaskType<unknown>>()(mask2)
 
   // Array options (no type parameter needed)
-  const mask3 = Mask.create(['name', 'age'])
+  const mask3 = Mask.create([`name`, `age`])
   const mask4 = Mask.create([])
-  const mask5 = Mask.create(['a', 'b', 'c'])
+  const mask5 = Mask.create([`a`, `b`, `c`])
   // Returns union type with inferred properties
   Ts.assertEqual<MaskType<{ name: any; age: any }>>()(mask3)
   Ts.assertEqual<MaskType<unknown>>()(mask4)
@@ -48,11 +48,15 @@ import type { InferOptions, Mask as MaskType, PropertiesMask } from './mask.ts'
 
 // Test 3: With specific data type, options are constrained
 {
-  type User = { name: string; age: number; email: string }
+  interface User {
+    name: string
+    age: number
+    email: string
+  }
 
   // Valid options
   const mask1 = Mask.create<User>(true)
-  const mask2 = Mask.create<User>(['name', 'age'])
+  const mask2 = Mask.create<User>([`name`, `age`])
   const mask3 = Mask.create<User>({ name: true, age: false, email: true })
 
   // With explicit type parameter, still returns union type
@@ -81,18 +85,18 @@ import type { InferOptions, Mask as MaskType, PropertiesMask } from './mask.ts'
 // Test 5: Test inference in practical scenarios
 {
   // Should infer PropertiesMask with object data type
-  const userMask = Mask.create(['name', 'email', 'password'])
+  const userMask = Mask.create([`name`, `email`, `password`])
   Ts.assertEqual<MaskType<{ name: any; email: any; password: any }>>()(userMask)
 
   // When mask is a union type, apply returns a union of possible results
-  const user1 = { name: 'John', email: 'john@example.com', password: 'secret', extra: 'data' }
+  const user1 = { name: `John`, email: `john@example.com`, password: `secret`, extra: `data` }
   const maskedUser1 = Mask.apply(user1, userMask)
   // Result is a union type that includes the properties mask result
   type MaskedUser1 = typeof maskedUser1
   // Can't use assertSub with union types
 
   // For partial data, use applyPartial
-  const user2 = { name: 'Jane', email: 'jane@example.com' }
+  const user2 = { name: `Jane`, email: `jane@example.com` }
   const maskedUser2 = Mask.applyPartial(user2, userMask)
   // Result is a union type
   type MaskedUser2 = typeof maskedUser2
@@ -100,16 +104,20 @@ import type { InferOptions, Mask as MaskType, PropertiesMask } from './mask.ts'
 
 // Test 6: Pick and omit helpers
 {
-  const pick1 = Mask.pick(['name', 'email'])
-  const omit1 = Mask.omit(['password', 'secret'])
+  const pick1 = Mask.pick([`name`, `email`])
+  const omit1 = Mask.omit([`password`, `secret`])
 
   // Infers specific property types
   Ts.assertEqual<PropertiesMask<{ name: any; email: any }>>()(pick1)
   Ts.assertEqual<PropertiesMask<{ password: any; secret: any }>>()(omit1)
 
-  type User = { name: string; email: string; password: string }
-  const pick2 = Mask.pick<User>(['name', 'email'])
-  const omit2 = Mask.omit<User>(['password'])
+  interface User {
+    name: string
+    email: string
+    password: string
+  }
+  const pick2 = Mask.pick<User>([`name`, `email`])
+  const omit2 = Mask.omit<User>([`password`])
 
   Ts.assertEqual<PropertiesMask<User>>()(pick2)
   Ts.assertEqual<PropertiesMask<User>>()(omit2)
@@ -117,8 +125,12 @@ import type { InferOptions, Mask as MaskType, PropertiesMask } from './mask.ts'
 
 // Test 7: Apply type transformations
 {
-  type User = { name: string; email: string; password: string }
-  const user: User = { name: 'John', email: 'john@example.com', password: 'secret' }
+  interface User {
+    name: string
+    email: string
+    password: string
+  }
+  const user: User = { name: `John`, email: `john@example.com`, password: `secret` }
 
   // Binary mask
   const showMask = Mask.create<User>(true)
@@ -131,7 +143,7 @@ import type { InferOptions, Mask as MaskType, PropertiesMask } from './mask.ts'
   type HiddenType = typeof hidden // Omit<User, keyof User> | undefined
 
   // Properties mask - allow mode
-  const allowMask = Mask.create<User>(['name', 'email'])
+  const allowMask = Mask.create<User>([`name`, `email`])
   const allowed = Mask.apply(user, allowMask)
   // Result is a union due to mask being a union type
   type AllowedType = typeof allowed

package/src/lib/mask/mask.ts

@@ -44,13 +44,13 @@ export type Mask<$Data = any> = BinaryMask<$Data> | PropertiesMask<$Data extends
 export const create = <$Data = unknown>(
   options: InferOptions<$Data>,
 ): Mask<$Data> => {
-  if (typeof options === 'boolean') {
+  if (typeof options === `boolean`) {
     return createBinary(options) as any
   }
 
   // Array input -> PropertiesMask with 'allow' mode
   if (Array.isArray(options)) {
-    return createProperties('allow', options as any) as any
+    return createProperties(`allow`, options as any) as any
   }
 
   // Object input -> PropertiesMask based on true/false values
@@ -66,11 +66,11 @@ export const create = <$Data = unknown>(
 
   // If we have denied keys, use deny mode
   if (deniedKeys.length > 0 && allowedKeys.length === 0) {
-    return createProperties('deny', deniedKeys) as any
+    return createProperties(`deny`, deniedKeys) as any
   }
 
   // Default to allow mode with allowed keys
-  return createProperties('allow', allowedKeys) as any
+  return createProperties(`allow`, allowedKeys) as any
 }
 
 /**
@@ -104,9 +104,9 @@ export type InferOptions<$Data> = unknown extends $Data ? boolean | string[] | R
  * @template $Data - The object type being masked
  */
 export interface PropertiesMask<$Data extends object = object> {
-  type: 'properties'
+  type: `properties`
   /** Whether to allow only specified properties or deny them */
-  mode: 'allow' | 'deny'
+  mode: `allow` | `deny`
   /** The list of property keys to allow or deny */
   properties: (keyof $Data)[]
 }
@@ -119,10 +119,10 @@ export interface PropertiesMask<$Data extends object = object> {
  * @returns A PropertiesMask
  */
 export const createProperties = <$Data extends object = object>(
-  mode: 'allow' | 'deny',
+  mode: `allow` | `deny`,
   properties: (keyof $Data)[],
 ): PropertiesMask<$Data> => ({
-  type: 'properties',
+  type: `properties`,
   mode,
   properties,
 })
@@ -140,8 +140,8 @@ export const createProperties = <$Data extends object = object>(
  *
  * @template _$Data - The data type being masked (used for type inference)
  */
-export type BinaryMask<_$Data = any> = {
-  type: 'binary'
+export interface BinaryMask<_$Data = any> {
+  type: `binary`
   /** Whether to show (true) or hide (false) the data */
   show: boolean
 }
@@ -153,7 +153,7 @@ export type BinaryMask<_$Data = any> = {
  * @returns A BinaryMask
  */
 export const createBinary = <$Data = any>(show: boolean): BinaryMask<$Data> => ({
-  type: 'binary',
+  type: `binary`,
   show,
 })
 
@@ -170,7 +170,7 @@ export const createBinary = <$Data = any>(show: boolean): BinaryMask<$Data> => (
  * @returns A BinaryMask with show=true
  */
 export const show = (): BinaryMask => ({
-  type: 'binary',
+  type: `binary`,
   show: true,
 })
 
@@ -179,7 +179,7 @@ export const show = (): BinaryMask => ({
  * @returns A BinaryMask with show=false
  */
 export const hide = (): BinaryMask => ({
-  type: 'binary',
+  type: `binary`,
   show: false,
 })
 
@@ -198,8 +198,8 @@ export const hide = (): BinaryMask => ({
 export const pick = <$Data extends object = object>(
   properties: (keyof $Data)[],
 ): PropertiesMask<$Data> => ({
-  type: 'properties',
-  mode: 'allow',
+  type: `properties`,
+  mode: `allow`,
   properties,
 })
 
@@ -218,8 +218,8 @@ export const pick = <$Data extends object = object>(
 export const omit = <$Data extends object = object>(
   properties: (keyof $Data)[],
 ): PropertiesMask<$Data> => ({
-  type: 'properties',
-  mode: 'deny',
+  type: `properties`,
+  mode: `deny`,
   properties,
 })
 
@@ -238,7 +238,7 @@ export const omit = <$Data extends object = object>(
  * @returns The data type the mask is designed for
  */
 // dprint-ignore
-export type GetDataType<$Mask extends Mask<any>> =
+export type GetDataType<$Mask extends Mask> =
   $Mask extends BinaryMask<infer $Data>     ? $Data :
   $Mask extends PropertiesMask<infer $Data> ? $Data
                                             : never

package/src/lib/mutation-type.ts

@@ -1,7 +1,7 @@
 export const MutationType = {
-  Create: 'create',
-  Update: 'update',
-  Delete: 'delete',
+  Create: `create`,
+  Update: `update`,
+  Delete: `delete`,
 } as const
 
 export type MutationType = typeof MutationType[keyof typeof MutationType]

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

@@ -0,0 +1,7 @@
+/**
+ * PathMap barrel export
+ *
+ * @module
+ */
+
+export * from './path-map.js'

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

@@ -0,0 +1,373 @@
+import * as fc from 'fast-check'
+import { describe, expect, it } from 'vitest'
+import { PathMap } from './$.js'
+
+describe('PathMap', () => {
+  describe('create', () => {
+    it('returns RelativePathMap when no base provided', () => {
+      const paths = PathMap.create({
+        src: {
+          lib: {
+            utils: 'utils.ts',
+          },
+        },
+      })
+
+      expect(paths).not.toHaveProperty('rooted')
+      expect(paths).not.toHaveProperty('absolute')
+      expect(paths).not.toHaveProperty('base')
+      expect(paths.src.lib.utils).toBe('utils.ts')
+    })
+
+    it('returns PathMap with all variants when base provided', () => {
+      const paths = PathMap.create({
+        src: {
+          lib: {
+            utils: 'utils.ts',
+          },
+        },
+      }, '/project')
+
+      expect(paths).toHaveProperty('relative')
+      expect(paths).toHaveProperty('rooted')
+      expect(paths).toHaveProperty('absolute')
+      expect(paths).toHaveProperty('base')
+      expect(paths.base).toBe('/project')
+    })
+
+    it('processes relative paths correctly', () => {
+      const paths = PathMap.create({
+        template: {
+          server: {
+            app: 'app.ts',
+            main: 'main.ts',
+          },
+          client: {
+            entry: 'entry.tsx',
+          },
+          'routes.tsx': 'routes.tsx',
+        },
+      }, '/base')
+
+      // Relative paths - local to parent
+      expect(paths.relative.template.server.app).toBe('app.ts')
+      expect(paths.relative.template.server.main).toBe('main.ts')
+      expect(paths.relative.template.client.entry).toBe('entry.tsx')
+      expect(paths.relative.template['routes.tsx']).toBe('routes.tsx')
+
+      // Directory $ properties - just the segment name
+      expect(paths.relative.$).toBe('.')
+      expect(paths.relative.template.$).toBe('template')
+      expect(paths.relative.template.server.$).toBe('server')
+      expect(paths.relative.template.client.$).toBe('client')
+    })
+
+    it('processes rooted paths correctly', () => {
+      const paths = PathMap.create({
+        template: {
+          server: {
+            app: 'app.ts',
+            main: 'main.ts',
+          },
+          client: {
+            entry: 'entry.tsx',
+          },
+        },
+      }, '/base')
+
+      // Rooted paths - from PathMap root
+      expect(paths.rooted.template.server.app).toBe('template/server/app.ts')
+      expect(paths.rooted.template.server.main).toBe('template/server/main.ts')
+      expect(paths.rooted.template.client.entry).toBe('template/client/entry.tsx')
+
+      // Directory $ properties - full path from root
+      expect(paths.rooted.$).toBe('.')
+      expect(paths.rooted.template.$).toBe('template')
+      expect(paths.rooted.template.server.$).toBe('template/server')
+      expect(paths.rooted.template.client.$).toBe('template/client')
+    })
+
+    it('processes absolute paths correctly', () => {
+      const paths = PathMap.create({
+        template: {
+          server: {
+            app: 'app.ts',
+            main: 'main.ts',
+          },
+          client: {
+            entry: 'entry.tsx',
+          },
+        },
+      }, '/project')
+
+      // Absolute paths
+      expect(paths.absolute.template.server.app).toBe('/project/template/server/app.ts')
+      expect(paths.absolute.template.server.main).toBe('/project/template/server/main.ts')
+      expect(paths.absolute.template.client.entry).toBe('/project/template/client/entry.tsx')
+
+      // Directory $ properties
+      expect(paths.absolute.$).toBe('/project')
+      expect(paths.absolute.template.$).toBe('/project/template')
+      expect(paths.absolute.template.server.$).toBe('/project/template/server')
+      expect(paths.absolute.template.client.$).toBe('/project/template/client')
+    })
+
+    it('handles deeply nested structures', () => {
+      const paths = PathMap.create({
+        a: {
+          b: {
+            c: {
+              d: {
+                e: 'file.ts',
+              },
+            },
+          },
+        },
+      }, '/root')
+
+      expect(paths.relative.a.b.c.d.e).toBe('file.ts')
+      expect(paths.rooted.a.b.c.d.e).toBe('a/b/c/d/file.ts')
+      expect(paths.absolute.a.b.c.d.e).toBe('/root/a/b/c/d/file.ts')
+
+      expect(paths.relative.a.b.c.d.$).toBe('d')
+      expect(paths.rooted.a.b.c.d.$).toBe('a/b/c/d')
+      expect(paths.absolute.a.b.c.d.$).toBe('/root/a/b/c/d')
+    })
+
+    it('handles quoted property names', () => {
+      const paths = PathMap.create({
+        'src-files': {
+          'main.config.ts': 'main.config.ts',
+          '.env': '.env',
+        },
+      }, '/app')
+
+      expect(paths.relative['src-files']['main.config.ts']).toBe('main.config.ts')
+      expect(paths.relative['src-files']['.env']).toBe('.env')
+      expect(paths.rooted['src-files']['main.config.ts']).toBe('src-files/main.config.ts')
+      expect(paths.absolute['src-files']['.env']).toBe('/app/src-files/.env')
+    })
+  })
+
+  describe('rebase', () => {
+    it('creates new PathMap with different base', () => {
+      const original = PathMap.create({
+        src: {
+          lib: 'lib.ts',
+        },
+      }, '/original')
+
+      const rebased = PathMap.rebase(original, '/new')
+
+      expect(rebased.base).toBe('/new')
+      expect(rebased.absolute.src.lib).toBe('/new/src/lib.ts')
+      // Relative and rooted should remain the same
+      expect(rebased.relative.src.lib).toBe('lib.ts')
+      expect(rebased.rooted.src.lib).toBe('src/lib.ts')
+    })
+
+    it('can rebase from RelativePathMap', () => {
+      const relative = PathMap.create({
+        src: {
+          lib: 'lib.ts',
+        },
+      })
+
+      const based = PathMap.rebase(relative, '/base')
+
+      expect(based.base).toBe('/base')
+      expect(based.absolute.src.lib).toBe('/base/src/lib.ts')
+      expect(based.relative.src.lib).toBe('lib.ts')
+      expect(based.rooted.src.lib).toBe('src/lib.ts')
+    })
+
+    it('supports chained rebasing', () => {
+      const p1 = PathMap.create({ src: { file: 'file.ts' } }, '/base1')
+      const p2 = PathMap.rebase(p1, '/base2')
+      const p3 = PathMap.rebase(p2, '/base3')
+
+      expect(p1.base).toBe('/base1')
+      expect(p2.base).toBe('/base2')
+      expect(p3.base).toBe('/base3')
+
+      expect(p1.absolute.src.file).toBe('/base1/src/file.ts')
+      expect(p2.absolute.src.file).toBe('/base2/src/file.ts')
+      expect(p3.absolute.src.file).toBe('/base3/src/file.ts')
+    })
+  })
+
+  describe('property tests', () => {
+    // Helper to normalize base paths the same way PathMap.create does
+    const normalizeBasePath = (base: string): string => {
+      const trimmedBase = base.trim()
+      const collapsedBase = trimmedBase.replace(/\/+/g, '/')
+      const cleanedBase = collapsedBase === '/.' ? '/' : collapsedBase
+      return cleanedBase === '/' ? '/' : cleanedBase.replace(/\/$/, '')
+    }
+
+    // Helper to build absolute paths with proper handling of root base
+    const buildAbsolutePath = (normalizedBase: string, segments: string[]): string => {
+      if (segments.length === 0) return normalizedBase
+      return normalizedBase === '/'
+        ? `/${segments.join('/')}`
+        : `${normalizedBase}/${segments.join('/')}`
+    }
+
+    // Arbitrary for valid path segments
+    const pathSegment = fc.stringMatching(/^[a-zA-Z0-9_-]+$/)
+
+    // Arbitrary for file names
+    const fileName = fc.stringMatching(/^[a-zA-Z0-9_-]+\.(ts|js|tsx|jsx)$/)
+
+    // Arbitrary for path input structures
+    const pathInput = fc.letrec<{ pathInput: PathMap.PathInput }>(tie => ({
+      pathInput: fc.dictionary(
+        pathSegment,
+        fc.oneof(
+          fileName,
+          tie('pathInput'),
+        ),
+        { minKeys: 1, maxKeys: 3 },
+      ),
+    })).pathInput
+
+    it('relative paths are always substrings of rooted paths', () => {
+      fc.assert(
+        fc.property(pathInput, fc.string({ minLength: 1 }).filter(s => s.startsWith('/')), (input, base) => {
+          const paths = PathMap.create(input, base)
+
+          // For every file path, relative should be at the end of rooted
+          function check(rel: any, rooted: any) {
+            for (const [key, value] of Object.entries(rel)) {
+              if (key === '$') continue
+
+              if (typeof value === 'string' && typeof rooted[key] === 'string') {
+                expect(rooted[key]).toContain(value)
+                expect(rooted[key].endsWith(value)).toBe(true)
+              } else if (typeof value === 'object') {
+                check(value, rooted[key])
+              }
+            }
+          }
+
+          check(paths.relative, paths.rooted)
+        }),
+      )
+    })
+
+    it('absolute paths always start with base', () => {
+      fc.assert(
+        fc.property(pathInput, fc.string({ minLength: 1 }).filter(s => s.startsWith('/')), (input, base) => {
+          const paths = PathMap.create(input, base)
+          const normalizedBase = normalizeBasePath(base)
+
+          function checkAbsolute(obj: any) {
+            for (const [key, value] of Object.entries(obj)) {
+              if (typeof value === 'string') {
+                expect(value.startsWith(normalizedBase)).toBe(true)
+              } else if (typeof value === 'object') {
+                checkAbsolute(value)
+              }
+            }
+          }
+
+          checkAbsolute(paths.absolute)
+        }),
+      )
+    })
+
+    it('rebase preserves structure', () => {
+      fc.assert(
+        fc.property(
+          pathInput,
+          fc.string({ minLength: 1 }).filter(s => s.startsWith('/')),
+          fc.string({ minLength: 1 }).filter(s => s.startsWith('/')),
+          (input, base1, base2) => {
+            const p1 = PathMap.create(input, base1)
+            const p2 = PathMap.rebase(p1, base2)
+
+            // Structure should be identical
+            expect(JSON.stringify(p1.relative)).toBe(JSON.stringify(p2.relative))
+            expect(JSON.stringify(p1.rooted)).toBe(JSON.stringify(p2.rooted))
+
+            // Only absolute paths and base should change
+            // Use the normalized base from the PathMap itself
+            function checkBase(obj: any) {
+              for (const [key, value] of Object.entries(obj)) {
+                if (typeof value === 'string') {
+                  expect(value.startsWith(p2.base)).toBe(true)
+                } else if (typeof value === 'object') {
+                  checkBase(value)
+                }
+              }
+            }
+
+            checkBase(p2.absolute)
+          },
+        ),
+      )
+    })
+
+    it('$ properties are consistent across variants', () => {
+      fc.assert(
+        fc.property(pathInput, fc.string({ minLength: 1 }).filter(s => s.startsWith('/')), (input, base) => {
+          const paths = PathMap.create(input, base)
+
+          function checkDirs(rel: any, rooted: any, abs: any, currentPath: string[] = []) {
+            if (rel.$ && rooted.$ && abs.$) {
+              // Relative $ should be just the last segment or '.'
+              if (currentPath.length === 0) {
+                expect(rel.$).toBe('.')
+                expect(rooted.$).toBe('.')
+                const normalizedBase = normalizeBasePath(base)
+                expect(abs.$).toBe(normalizedBase)
+              } else {
+                expect(rel.$).toBe(currentPath[currentPath.length - 1])
+                expect(rooted.$).toBe(currentPath.join('/'))
+                const normalizedBase = normalizeBasePath(base)
+                const expectedAbs = buildAbsolutePath(normalizedBase, currentPath)
+                expect(abs.$).toBe(expectedAbs)
+              }
+            }
+
+            for (const key of Object.keys(rel)) {
+              if (key === '$' || typeof rel[key] === 'string') continue
+              if (rel[key] && rooted[key] && abs[key]) {
+                checkDirs(rel[key], rooted[key], abs[key], [...currentPath, key])
+              }
+            }
+          }
+
+          checkDirs(paths.relative, paths.rooted, paths.absolute)
+        }),
+      )
+    })
+  })
+
+  describe('type safety', () => {
+    it('maintains type information through operations', () => {
+      const paths = PathMap.create({
+        src: {
+          lib: {
+            utils: 'utils.ts',
+            helpers: 'helpers.ts',
+          },
+          components: {
+            Button: 'Button.tsx',
+          },
+        },
+      }, '/project')
+
+      // TypeScript should know about these paths
+      const _utils: string = paths.relative.src.lib.utils
+      const _button: string = paths.absolute.src.components.Button
+      const _libDir: string = paths.rooted.src.lib.$
+
+      // @ts-expect-error - should not exist
+      paths.relative.src.lib.unknown
+
+      // @ts-expect-error - should not exist
+      paths.absolute.notThere
+    })
+  })
+})

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

@@ -0,0 +1,7 @@
+/**
+ * PathMap namespace export
+ *
+ * @module
+ */
+
+export * as PathMap from './$$.js'