npm - polen - Versions diffs - 0.10.0-next.8 → 0.10.0 - Mend

polen 0.10.0-next.8 → 0.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1298) hide show

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

@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest'
+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 },
+    }
+    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()
+  })
+})
+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;')
+    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 = `
+<html>
+  <head>
+    <title>Test</title>
+  </head>
+  <body>
+    <div id="app"></div>
+  </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__);')
+  })
+})

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

@@ -0,0 +1,80 @@
+/**
+ * Creates an HTML script tag that injects data into a global variable
+ *
+ * @param globalName - The name of the global variable (e.g., '__POLEN__')
+ * @param data - The data to inject (will be JSON stringified)
+ * @returns HTML script tag string ready to inject into HTML
+ *
+ * @example
+ * ```ts
+ * const script = createGlobalDataScript('__MY_APP__', { user: { id: 1, name: 'John' } })
+ * // Returns: <script>globalThis.__MY_APP__ = {"user":{"id":1,"name":"John"}};</script>
+ * ```
+ */
+export const createGlobalDataScript = (globalName: string, data: unknown): string => {
+  // Validate global name to prevent injection attacks
+  if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(globalName)) {
+    throw new Error(`Invalid global variable name: ${globalName}`)
+  }
+  // JSON.stringify and then escape </script> tags to prevent XSS
+  const jsonData = JSON.stringify(data)
+    // Escape </script> to prevent breaking out of script tag
+    .replace(/<\/script>/gi, '<\\/script>')
+  return `<script>globalThis.${globalName} = ${jsonData};</script>`
+}
+/**
+ * Creates a script tag that initializes global data and runs initialization code
+ *
+ * @param globalName - The name of the global variable
+ * @param data - The data to inject
+ * @param initCode - Optional initialization code to run after setting the global
+ * @returns HTML script tag string
+ *
+ * @example
+ * ```ts
+ * const script = createGlobalDataScriptWithInit('__THEME__', { theme: 'dark' }, `
+ *   document.documentElement.className = globalThis.__THEME__.theme;
+ * `)
+ * ```
+ */
+export const createGlobalDataScriptWithInit = (
+  globalName: string,
+  data: unknown,
+  initCode?: string,
+): string => {
+  const dataScript = createGlobalDataScript(globalName, data)
+  if (!initCode) {
+    return dataScript
+  }
+  // Remove the closing </script> tag from data script and append init code
+  const scriptContent = dataScript.replace('</script>', `\n${initCode}\n</script>`)
+  return scriptContent
+}
+/**
+ * Injects a global data script into the head of an HTML document
+ *
+ * @param html - The HTML document string
+ * @param globalName - The name of the global variable
+ * @param data - The data to inject
+ * @param initCode - Optional initialization code
+ * @returns Modified HTML with script injected
+ */
+export const injectGlobalDataIntoHTML = (
+  html: string,
+  globalName: string,
+  data: unknown,
+  initCode?: string,
+): string => {
+  const script = initCode
+    ? createGlobalDataScriptWithInit(globalName, data, initCode)
+    : createGlobalDataScript(globalName, data)
+  // Inject at the beginning of head to ensure it runs first
+  return html.replace('<head>', `<head>\n${script}`)
+}

package/src/lib/kit-temp.test-d.ts CHANGED Viewed

@@ -3,24 +3,29 @@ import { objFilter, ObjOmit, ObjPick, objPolicyFilter } from './kit-temp.js'
 import type { ObjPolicyFilter } from './kit-temp.js'
 // Test object for all tests
-type TestObj = { a: string; b: number; c: boolean; d: string[] }
+interface TestObj {
+  a: string
+  b: number
+  c: boolean
+  d: string[]
+}
 declare const testObj: TestObj
 // Test 1: objPolicyFilter with allow mode
 {
-  const result = objPolicyFilter('allow', testObj, ['a', 'c'] as const)
+  const result = objPolicyFilter(`allow`, testObj, [`a`, `c`] as const)
   Ts.assertEqual<{ a: string; c: boolean }>()(result)
 }
 // Test 2: objPolicyFilter with deny mode
 {
-  const result = objPolicyFilter('deny', testObj, ['a', 'c'] as const)
+  const result = objPolicyFilter(`deny`, testObj, [`a`, `c`] as const)
   Ts.assertEqual<{ b: number; d: string[] }>()(result)
 }
 // Test 3: objFilter returns Partial<T>
 {
-  const result = objFilter(testObj, (key, value) => value !== 'hello')
+  const result = objFilter(testObj, (key, value) => value !== `hello`)
   Ts.assertEqual<Partial<TestObj>>()(result)
   // All properties are optional
@@ -32,28 +37,28 @@ declare const testObj: TestObj
 // Test 4: ObjPick type inference
 {
-  const result = ObjPick(testObj, ['a', 'c'] as const)
+  const result = ObjPick(testObj, [`a`, `c`] as const)
   Ts.assertEqual<{ a: string; c: boolean }>()(result)
 }
 // Test 5: ObjOmit type inference
 {
-  const result = ObjOmit(testObj, ['a', 'c'] as const)
+  const result = ObjOmit(testObj, [`a`, `c`] as const)
   Ts.assertEqual<{ b: number; d: string[] }>()(result)
 }
 // Test 6: ObjPolicyFilter type-level function
 {
-  type Allow = ObjPolicyFilter<TestObj, 'a' | 'c', 'allow'>
+  type Allow = ObjPolicyFilter<TestObj, `a` | `c`, `allow`>
   type _TestAllow = Ts.AssertEqual<Allow, { a: string; c: boolean }>
-  type Deny = ObjPolicyFilter<TestObj, 'a' | 'c', 'deny'>
+  type Deny = ObjPolicyFilter<TestObj, `a` | `c`, `deny`>
   type _TestDeny = Ts.AssertEqual<Deny, { b: number; d: string[] }>
-  type AllowEmpty = ObjPolicyFilter<TestObj, never, 'allow'>
+  type AllowEmpty = ObjPolicyFilter<TestObj, never, `allow`>
   type _TestAllowEmpty = Ts.AssertEqual<AllowEmpty, {}>
-  type DenyEmpty = ObjPolicyFilter<TestObj, never, 'deny'>
+  type DenyEmpty = ObjPolicyFilter<TestObj, never, `deny`>
   type _TestDenyEmpty = Ts.AssertEqual<DenyEmpty, TestObj>
 }
@@ -61,8 +66,8 @@ declare const testObj: TestObj
 {
   // Empty object
   const empty = {}
-  const allowEmpty = objPolicyFilter('allow', empty, [])
-  const denyEmpty = objPolicyFilter('deny', empty, [])
+  const allowEmpty = objPolicyFilter(`allow`, empty, [])
+  const denyEmpty = objPolicyFilter(`deny`, empty, [])
   const filterEmpty = objFilter(empty, () => true)
   Ts.assertEqual<{}>()(allowEmpty)
@@ -71,8 +76,8 @@ declare const testObj: TestObj
   // Single property object
   const single = { a: 1 }
-  const allowSingle = objPolicyFilter('allow', single, ['a'] as const)
-  const denySingle = objPolicyFilter('deny', single, ['a'] as const)
+  const allowSingle = objPolicyFilter(`allow`, single, [`a`] as const)
+  const denySingle = objPolicyFilter(`deny`, single, [`a`] as const)
   const filterSingle = objFilter(single, () => true)
   Ts.assertEqual<{ a: number }>()(allowSingle)
@@ -82,7 +87,7 @@ declare const testObj: TestObj
 // Test 8: Complex nested object
 {
-  type ComplexObj = {
+  interface ComplexObj {
     nested: { a: string; b: number }
     array: string[]
     optional?: boolean
@@ -90,26 +95,26 @@ declare const testObj: TestObj
   }
   const complexObj = {} as ComplexObj
-  const picked = objPolicyFilter('allow', complexObj, ['nested', 'optional'] as const)
+  const picked = objPolicyFilter(`allow`, complexObj, [`nested`, `optional`] as const)
   Ts.assertEqual<{ nested: { a: string; b: number }; optional?: boolean }>()(picked)
-  const omitted = objPolicyFilter('deny', complexObj, ['nested', 'optional'] as const)
+  const omitted = objPolicyFilter(`deny`, complexObj, [`nested`, `optional`] as const)
   Ts.assertEqual<{ array: string[]; readonly ro: string }>()(omitted)
-  const filtered = objFilter(complexObj, (key) => key !== 'array')
+  const filtered = objFilter(complexObj, (key) => key !== `array`)
   Ts.assertEqual<Partial<ComplexObj>>()(filtered)
 }
 // Test 9: Keys parameter type inference
 {
   // With const assertion
-  const keys1 = ['a', 'c'] as const
-  const result1 = objPolicyFilter('allow', testObj, keys1)
+  const keys1 = [`a`, `c`] as const
+  const result1 = objPolicyFilter(`allow`, testObj, keys1)
   Ts.assertEqual<{ a: string; c: boolean }>()(result1)
   // Without const assertion (wider type)
-  const keys2: (keyof TestObj)[] = ['a', 'c']
-  const result2 = objPolicyFilter('allow', testObj, keys2)
+  const keys2: (keyof TestObj)[] = [`a`, `c`]
+  const result2 = objPolicyFilter(`allow`, testObj, keys2)
   // Result is a union of all possible picks
   type Result2 = typeof result2 // Pick<TestObj, keyof TestObj>
 }

package/src/lib/kit-temp.test.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import * as fc from 'fast-check'
 import { describe, expect, test } from 'vitest'
-import { objFilter, ObjOmit, ObjPick, objPolicyFilter } from './kit-temp.js'
+import { objFilter, ObjOmit, ObjPick, objPolicyFilter, spreadShallow } from './kit-temp.js'
 describe('objPolicyFilter', () => {
   const testObj = { a: 1, b: 2, c: 3, d: 4 }
@@ -61,21 +61,35 @@ describe('property-based tests', () => {
   test('objPolicyFilter allow/deny are complementary', () => {
     fc.assert(
       fc.property(
-        fc.dictionary(fc.string(), fc.anything()),
+        fc.object(),
         fc.array(fc.string()),
         (obj, keys) => {
           const allowed = objPolicyFilter('allow', obj, keys)
           const denied = objPolicyFilter('deny', obj, keys)
-          // Every key in obj is either in allowed or denied, never both
+          // Every key in obj (own properties only) is either in allowed or denied, never both
           Object.keys(obj).forEach(key => {
             const inAllowed = Object.prototype.hasOwnProperty.call(allowed, key)
             const inDenied = Object.prototype.hasOwnProperty.call(denied, key)
             expect(inAllowed).toBe(!inDenied)
           })
-          // Combined they reconstruct the original object
-          expect({ ...allowed, ...denied }).toEqual(obj)
+          // Combined they reconstruct the original object's own properties
+          const reconstructed = { ...allowed, ...denied }
+          // Filter out inherited properties that may have been added from the keys
+          const filteredReconstructed = Object.keys(reconstructed)
+            .filter(key => Object.prototype.hasOwnProperty.call(obj, key))
+            .reduce<any>((acc, key) => {
+              acc[key] = (reconstructed as any)[key]
+              return acc
+            }, {})
+          const ownPropsObj = Object.keys(obj).reduce<any>((acc, key) => {
+            acc[key] = obj[key]
+            return acc
+          }, {})
+          expect(filteredReconstructed).toEqual(ownPropsObj)
         },
       ),
     )
@@ -84,10 +98,17 @@ describe('property-based tests', () => {
   test('objFilter preserves values unchanged', () => {
     fc.assert(
       fc.property(
-        fc.dictionary(fc.string(), fc.anything()),
+        fc.object(),
         (obj) => {
           const filtered = objFilter(obj, () => true)
-          expect(filtered).toEqual(obj)
+          // Object.keys doesn't include __proto__, so we need to handle it specially
+          const objWithoutProto = Object.keys(obj).reduce<any>((acc, key) => {
+            acc[key] = obj[key]
+            return acc
+          }, {})
+          expect(filtered).toEqual(objWithoutProto)
           // Values are the same reference
           Object.keys(filtered).forEach(key => {
@@ -101,7 +122,7 @@ describe('property-based tests', () => {
   test('objPolicyFilter is immutable', () => {
     fc.assert(
       fc.property(
-        fc.dictionary(fc.string(), fc.anything()),
+        fc.object(),
         fc.array(fc.string()),
         fc.oneof(fc.constant('allow' as const), fc.constant('deny' as const)),
         (obj, keys, mode) => {
@@ -116,7 +137,7 @@ describe('property-based tests', () => {
   test('empty keys behavior', () => {
     fc.assert(
       fc.property(
-        fc.dictionary(fc.string(), fc.anything()),
+        fc.object(),
         (obj) => {
           expect(objPolicyFilter('allow', obj, [])).toEqual({})
           expect(objPolicyFilter('deny', obj, [])).toEqual(obj)
@@ -125,3 +146,87 @@ describe('property-based tests', () => {
     )
   })
 })
+describe('mergeShallow', () => {
+  test('merges objects while omitting undefined values', () => {
+    const base = { a: 1, b: 2, c: 3 }
+    const override = { a: 1, b: undefined, c: 4, d: 5 }
+    expect(spreadShallow<any>(base, override)).toEqual({ a: 1, b: 2, c: 4, d: 5 })
+  })
+  test('handles multiple objects', () => {
+    const obj1 = { a: 1, b: 2 }
+    const obj2 = { a: 1, b: undefined, c: 3 }
+    const obj3 = { a: 1, b: 2, c: undefined, d: 4 }
+    expect(spreadShallow<any>(obj1, obj2, obj3)).toEqual({ a: 1, b: 2, c: 3, d: 4 })
+  })
+  test('handles empty objects', () => {
+    expect(spreadShallow({}, {})).toEqual({})
+    expect(spreadShallow({ a: 1 }, {})).toEqual({ a: 1 })
+    expect(spreadShallow({}, { a: 1 })).toEqual({ a: 1 })
+  })
+  test('handles single object', () => {
+    const obj = { a: 1, b: undefined, c: 3 }
+    expect(spreadShallow(obj)).toEqual({ a: 1, c: 3 })
+  })
+  test('handles no objects', () => {
+    expect(spreadShallow()).toEqual({})
+  })
+  test('handles undefined objects', () => {
+    const obj = { a: 1, b: 2 }
+    expect(spreadShallow(undefined, obj, undefined)).toEqual({ a: 1, b: 2 })
+    expect(spreadShallow(obj, undefined)).toEqual({ a: 1, b: 2 })
+    expect(spreadShallow(undefined, undefined)).toEqual({})
+  })
+  test('preserves null values', () => {
+    const obj1 = { a: 1, b: null }
+    const obj2 = { a: 1, b: 2, c: null }
+    expect(spreadShallow<any>(obj1, obj2)).toEqual({ a: 1, b: 2, c: null })
+  })
+  test('preserves false and 0 values', () => {
+    const obj1 = { a: true, b: 1 }
+    const obj2 = { a: false, b: 0 }
+    expect(spreadShallow(obj1, obj2)).toEqual({ a: false, b: 0 })
+  })
+  test('property-based: never includes undefined values', () => {
+    fc.assert(
+      fc.property(
+        fc.array(fc.dictionary(fc.string(), fc.option(fc.anything()))),
+        (objects) => {
+          const result = spreadShallow(...objects)
+          Object.values(result).forEach(value => {
+            expect(value).not.toBe(undefined)
+          })
+        },
+      ),
+    )
+  })
+  test('property-based: later objects override earlier ones', () => {
+    fc.assert(
+      fc.property(
+        fc.object(),
+        fc.object(),
+        fc.string(),
+        fc.anything().filter(v => v !== undefined),
+        (obj1, obj2, key, value) => {
+          // Set the same key in both objects
+          obj1[key] = 'first'
+          obj2[key] = value
+          const result = spreadShallow(obj1, obj2)
+          expect(result[key]).toBe(value)
+        },
+      ),
+    )
+  })
+})