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

package/src/lib/html-utils/inject-global-data.test.ts

@@ -1,67 +1,69 @@
-import { describe, expect, it } from 'vitest'
+import { expect } from 'vitest'
+import { Test } from '../../../tests/unit/helpers/test.js'
 import {
   createGlobalDataScript,
   createGlobalDataScriptWithInit,
   injectGlobalDataIntoHTML,
 } from './inject-global-data.js'
 
-describe('createGlobalDataScript', () => {
-  it('creates a script tag with JSON data', () => {
-    const result = createGlobalDataScript('__TEST__', { foo: 'bar', num: 42 })
-    expect(result).toBe('<script>globalThis.__TEST__ = {"foo":"bar","num":42};</script>')
-  })
-
-  it('handles nested data structures', () => {
-    const data = {
-      user: { id: 1, name: 'John' },
-      settings: { theme: 'dark', notifications: true },
+// dprint-ignore
+Test.suite<{ globalName: string; data: any; shouldThrow?: boolean; expectedContains?: string[]; expectedNotContains?: string[] }>('createGlobalDataScript', [
+  { name: 'creates a script tag with JSON data',         globalName: '__TEST__',    data: { foo: 'bar', num: 42 },                                          expectedContains: ['<script>globalThis.__TEST__ = {"foo":"bar","num":42};</script>'] },
+  { name: 'handles nested data structures',              globalName: '__APP__',     data: { user: { id: 1, name: 'John' }, settings: { theme: 'dark', notifications: true } }, expectedContains: ['globalThis.__APP__ =', JSON.stringify({ user: { id: 1, name: 'John' }, settings: { theme: 'dark', notifications: true } })] },
+  { name: 'escapes special characters in data',          globalName: '__SAFE__',    data: { html: '</script><script>alert("xss")</script>' },                expectedNotContains: ['</script><script>'], expectedContains: ['<\\/script>'] },
+  { name: 'throws on invalid global name (starts with number)', globalName: '123invalid',  data: {},                                                                shouldThrow: true },
+  { name: 'throws on invalid global name (with dash)',   globalName: 'invalid-name', data: {},                                                               shouldThrow: true },
+  { name: 'throws on invalid global name (with dot)',    globalName: 'invalid.name', data: {},                                                               shouldThrow: true },
+  { name: 'accepts valid global name (underscore)',      globalName: '_valid',      data: {},                                                                shouldThrow: false },
+  { name: 'accepts valid global name (dollar)',          globalName: '$valid',      data: {},                                                                shouldThrow: false },
+  { name: 'accepts valid global name (alphanumeric)',    globalName: 'VALID_123',   data: {},                                                                shouldThrow: false },
+], ({ globalName, data, shouldThrow, expectedContains, expectedNotContains }) => {
+  if (shouldThrow) {
+    expect(() => createGlobalDataScript(globalName, data)).toThrow('Invalid global variable name')
+  } else {
+    const result = createGlobalDataScript(globalName, data)
+    
+    if (expectedContains) {
+      expectedContains.forEach(expected => {
+        if (expected === result) {
+          expect(result).toBe(expected)
+        } else {
+          expect(result).toContain(expected)
+        }
+      })
     }
-    const result = createGlobalDataScript('__APP__', data)
-    expect(result).toContain('globalThis.__APP__ =')
-    expect(result).toContain(JSON.stringify(data))
-  })
-
-  it('escapes special characters in data', () => {
-    const data = { html: '</script><script>alert("xss")</script>' }
-    const result = createGlobalDataScript('__SAFE__', data)
-    // JSON.stringify escapes the forward slashes
-    expect(result).not.toContain('</script><script>')
-    expect(result).toContain('<\\/script>')
-  })
-
-  it('throws on invalid global names', () => {
-    expect(() => createGlobalDataScript('123invalid', {})).toThrow('Invalid global variable name')
-    expect(() => createGlobalDataScript('invalid-name', {})).toThrow('Invalid global variable name')
-    expect(() => createGlobalDataScript('invalid.name', {})).toThrow('Invalid global variable name')
-  })
-
-  it('accepts valid global names', () => {
-    expect(() => createGlobalDataScript('_valid', {})).not.toThrow()
-    expect(() => createGlobalDataScript('$valid', {})).not.toThrow()
-    expect(() => createGlobalDataScript('VALID_123', {})).not.toThrow()
-  })
+    
+    if (expectedNotContains) {
+      expectedNotContains.forEach(notExpected => {
+        expect(result).not.toContain(notExpected)
+      })
+    }
+    
+    if (!shouldThrow && !expectedContains && !expectedNotContains) {
+      // For valid name tests, just ensure it doesn't throw
+      expect(result).toBeDefined()
+    }
+  }
 })
 
-describe('createGlobalDataScriptWithInit', () => {
-  it('creates script with data and init code', () => {
-    const result = createGlobalDataScriptWithInit(
-      '__THEME__',
-      { theme: 'dark' },
-      'document.body.className = globalThis.__THEME__.theme;',
-    )
-    expect(result).toContain('globalThis.__THEME__ = {"theme":"dark"};')
-    expect(result).toContain('document.body.className = globalThis.__THEME__.theme;')
+// dprint-ignore
+Test.suite<{ globalName: string; data: any; initCode?: string; expectedContains?: string[]; exactMatch?: string }>('createGlobalDataScriptWithInit', [
+  { name: 'creates script with data and init code',       globalName: '__THEME__', data: { theme: 'dark' }, initCode: 'document.body.className = globalThis.__THEME__.theme;', expectedContains: ['globalThis.__THEME__ = {"theme":"dark"};', 'document.body.className = globalThis.__THEME__.theme;'] },
+  { name: 'returns just data script when no init code',   globalName: '__TEST__',  data: { foo: 'bar' },                                                                                        exactMatch: '<script>globalThis.__TEST__ = {"foo":"bar"};</script>' },
+], ({ globalName, data, initCode, expectedContains, exactMatch }) => {
+  const result = createGlobalDataScriptWithInit(globalName, data, initCode)
+  
+  if (exactMatch) {
+    expect(result).toBe(exactMatch)
+  } else if (expectedContains) {
+    expectedContains.forEach(expected => {
+      expect(result).toContain(expected)
+    })
     expect(result).toMatch(/<script>.*<\/script>/s)
-  })
-
-  it('returns just data script when no init code provided', () => {
-    const result = createGlobalDataScriptWithInit('__TEST__', { foo: 'bar' })
-    expect(result).toBe('<script>globalThis.__TEST__ = {"foo":"bar"};</script>')
-  })
+  }
 })
 
-describe('injectGlobalDataIntoHTML', () => {
-  const sampleHTML = `
+const sampleHTML = `
 <html>
   <head>
     <title>Test</title>
@@ -71,19 +73,14 @@ describe('injectGlobalDataIntoHTML', () => {
   </body>
 </html>`
 
-  it('injects script into head', () => {
-    const result = injectGlobalDataIntoHTML(sampleHTML, '__APP__', { version: '1.0' })
-    expect(result).toContain('<head>\n<script>globalThis.__APP__ = {"version":"1.0"};</script>')
-  })
-
-  it('injects script with init code', () => {
-    const result = injectGlobalDataIntoHTML(
-      sampleHTML,
-      '__CONFIG__',
-      { apiUrl: '/api' },
-      'console.log("Config loaded:", globalThis.__CONFIG__);',
-    )
-    expect(result).toContain('globalThis.__CONFIG__ = {"apiUrl":"/api"};')
-    expect(result).toContain('console.log("Config loaded:", globalThis.__CONFIG__);')
+// dprint-ignore
+Test.suite<{ globalName: string; data: any; initCode?: string; expectedContains: string[] }>('injectGlobalDataIntoHTML', [
+  { name: 'injects script into head',                     globalName: '__APP__',    data: { version: '1.0' },                                               expectedContains: ['<head>\n<script>globalThis.__APP__ = {"version":"1.0"};</script>'] },
+  { name: 'injects script with init code',                globalName: '__CONFIG__', data: { apiUrl: '/api' }, initCode: 'console.log("Config loaded:", globalThis.__CONFIG__);', expectedContains: ['globalThis.__CONFIG__ = {"apiUrl":"/api"};', 'console.log("Config loaded:", globalThis.__CONFIG__);'] },
+], ({ globalName, data, initCode, expectedContains }) => {
+  const result = injectGlobalDataIntoHTML(sampleHTML, globalName, data, initCode)
+  
+  expectedContains.forEach(expected => {
+    expect(result).toContain(expected)
   })
 })

package/src/lib/kit-temp/$$.ts

@@ -0,0 +1,6 @@
+export * from './array.js'
+export * from './effect.js'
+export * from './global-local-check.js'
+export * as Ob from './ob.js'
+export * from './other.js'
+export * as Resource from './resource.js'

package/src/lib/kit-temp/$.ts

@@ -0,0 +1,2 @@
+// Namespace export for kit-temp library
+export * from './$$.js'

package/src/lib/kit-temp/array.ts

@@ -0,0 +1,30 @@
+// Smart chunking that considers route complexity
+export function chunkByWeight<T>(
+  items: T[],
+  targetChunks: number,
+  getWeight: (item: T) => number = () => 1,
+): T[][] {
+  const totalWeight = items.reduce((sum, item) => sum + getWeight(item), 0)
+  const targetWeight = totalWeight / targetChunks
+
+  const chunks: T[][] = []
+  let currentChunk: T[] = []
+  let currentWeight = 0
+
+  for (const item of items) {
+    const weight = getWeight(item)
+    if (currentWeight + weight > targetWeight && currentChunk.length > 0) {
+      chunks.push(currentChunk)
+      currentChunk = []
+      currentWeight = 0
+    }
+    currentChunk.push(item)
+    currentWeight += weight
+  }
+
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk)
+  }
+
+  return chunks
+}

package/src/lib/kit-temp/effect.test.ts

@@ -0,0 +1,124 @@
+import type { Case } from '#lib/kit-temp'
+import { EffectKit } from '#lib/kit-temp'
+import { S } from '#lib/kit-temp/effect'
+import { Ts } from '@wollybeard/kit'
+import { expect } from 'vitest'
+import { Test } from '../../../tests/unit/helpers/test.js'
+
+// Define test schemas
+const Added = S.TaggedStruct('LifecycleEventAdded', {
+  schema: S.Unknown,
+  revision: S.Unknown,
+})
+
+const Removed = S.TaggedStruct('LifecycleEventRemoved', {
+  schema: S.Unknown,
+  revision: S.Unknown,
+})
+
+const LifecycleEvent = S.Union(Added, Removed)
+
+// Create the factory
+const make = EffectKit.Schema.UnionAdt.makeMake(LifecycleEvent)
+
+interface MakeMakeTestCase {
+  testType: 'basic' | 'invalidTag' | 'complex'
+  tag?: string
+  data?: any
+  shouldThrow?: boolean
+  expectedTag?: string
+  expectedFields?: Record<string, any>
+}
+
+// dprint-ignore
+Test.suite<MakeMakeTestCase>('EffectKit.Schema.UnionAdt.makeMake', [
+  { name: 'creates Added variant with correct tag',       testType: 'basic',      tag: 'LifecycleEventAdded',    data: { schema: 'test-schema', revision: 'test-revision' }, expectedTag: 'LifecycleEventAdded', expectedFields: { schema: 'test-schema', revision: 'test-revision' } },
+  { name: 'creates Removed variant with correct tag',     testType: 'basic',      tag: 'LifecycleEventRemoved',  data: { schema: 'test-schema', revision: 'test-revision' }, expectedTag: 'LifecycleEventRemoved', expectedFields: { schema: 'test-schema', revision: 'test-revision' } },
+  { name: 'throws error for unknown tag',                 testType: 'invalidTag', tag: 'UnknownTag',             data: { schema: 'test', revision: 'test' },                 shouldThrow: true },
+  { name: 'works with complex field types - Added',       testType: 'complex',    tag: 'ComplexAdded',           data: { name: 'test', count: 42, nested: { value: 'nested-value' } }, expectedTag: 'ComplexAdded', expectedFields: { name: 'test', count: 42, nested: { value: 'nested-value' } } },
+  { name: 'works with complex field types - Removed',     testType: 'complex',    tag: 'ComplexRemoved',         data: { reason: 'test reason', timestamp: 123456 },         expectedTag: 'ComplexRemoved', expectedFields: { reason: 'test reason', timestamp: 123456 } },
+], ({ testType, tag, data, shouldThrow, expectedTag, expectedFields }) => {
+  if (testType === 'basic') {
+    const result = make(tag as any, data)
+    expect(result._tag).toBe(expectedTag)
+    if (expectedFields) {
+      Object.entries(expectedFields).forEach(([key, value]) => {
+        expect((result as any)[key]).toEqual(value)
+      })
+    }
+  } else if (testType === 'invalidTag') {
+    expect(() => {
+      make(tag as any, data)
+    }).toThrow('Unknown tag: UnknownTag')
+  } else if (testType === 'complex') {
+    const ComplexAdded = S.TaggedStruct('ComplexAdded', {
+      name: S.String,
+      count: S.Number,
+      nested: S.Struct({
+        value: S.String,
+      }),
+    })
+
+    const ComplexRemoved = S.TaggedStruct('ComplexRemoved', {
+      reason: S.String,
+      timestamp: S.Number,
+    })
+
+    const ComplexUnion = S.Union(ComplexAdded, ComplexRemoved)
+    const complexMake = EffectKit.Schema.UnionAdt.makeMake(ComplexUnion)
+    
+    const result = complexMake(tag as any, data)
+    expect(result._tag).toBe(expectedTag)
+    if (expectedFields) {
+      Object.entries(expectedFields).forEach(([key, value]) => {
+        expect((result as any)[key]).toEqual(value)
+      })
+    }
+  }
+})
+
+// Re-declare for type tests
+namespace _ {
+  const Added = S.TaggedStruct('LifecycleEventAdded', {
+    schema: S.Unknown,
+    revision: S.Unknown,
+  })
+
+  const Removed = S.TaggedStruct('LifecycleEventRemoved', {
+    schema: S.Unknown,
+    revision: S.Unknown,
+  })
+
+  const LifecycleEvent = S.Union(Added, Removed)
+  const make = EffectKit.Schema.UnionAdt.makeMake(LifecycleEvent)
+
+  type _ = [
+    // Test that factory function has correct signature
+    Case<
+      Ts.AssertExact<
+        typeof make,
+        EffectKit.Schema.UnionAdt.FnMake<typeof LifecycleEvent>
+      >
+    >,
+
+    // Test ExtractTags utility type
+    Case<
+      Ts.AssertExact<
+        EffectKit.Schema.UnionAdt.GetTags<typeof LifecycleEvent>,
+        'LifecycleEventAdded' | 'LifecycleEventRemoved'
+      >
+    >,
+
+    // Test ExtractMemberByTag utility type
+    // ExtractMemberByTag should return the decoded type of the member
+    // The type should have the tag and all fields from the schema
+
+    // Test OmitTag utility type
+    Case<
+      Ts.AssertExact<
+        EffectKit.TaggedStruct.OmitTag<{ _tag: 'test'; field: string }>,
+        { field: string }
+      >
+    >,
+  ]
+}