odac 1.4.5 → 1.4.7

package/src/View.js

@@ -103,6 +103,7 @@ class View {
     }
   }
   #part = {}
+  #refresh = new Set()
   #odac = null
 
   constructor(odac) {
@@ -148,10 +149,25 @@ class View {
         }
       }
 
-      // Render requested elements
+      // Build current parts manifest (part name → view path)
+      const currentParts = {}
+      for (let key in this.#part) {
+        if (['all', 'skeleton'].includes(key)) continue
+        if (this.#part[key]) currentParts[key] = this.#part[key]
+      }
+
+      // Parse client's previous parts to detect unchanged regions
+      const clientParts = this.#odac.Request.clientParts || {}
+
+      // Render requested elements (skip unchanged parts)
       let title = null
       for (let element of this.#odac.Request.ajaxLoad) {
         if (this.#part[element]) {
+          // Skip rendering if the part view path has not changed and refresh is not forced
+          // Content is always re-rendered since its output depends on the current URL
+          if (element !== 'content' && !this.#refresh.has(element) && clientParts[element] && clientParts[element] === this.#part[element])
+            continue
+
           let viewPath = this.#part[element]
           if (viewPath.includes('.')) viewPath = viewPath.replace(/\./g, '/')
           if (await this.#exists(`./view/${element}/${viewPath}.html`)) {
@@ -161,7 +177,7 @@ class View {
             // Extract title if present inside the part
             const titleMatch = html.match(TITLE_REGEX)
             if (titleMatch && titleMatch[1]) {
-              title = titleMatch[1]
+              title = titleMatch[1].trim()
             }
           }
         }
@@ -171,7 +187,8 @@ class View {
       if (!title) {
         const priorityParts = ['head', 'header', 'meta']
         for (const key of priorityParts) {
-          if (this.#part[key] && !this.#odac.Request.ajaxLoad.includes(key)) {
+          // Only extract if it wasn't already processed in the main loop above
+          if (this.#part[key] && output[key] === undefined) {
             let viewPath = this.#part[key]
             if (viewPath.includes('.')) viewPath = viewPath.replace(/\./g, '/')
             if (await this.#exists(`./view/${key}/${viewPath}.html`)) {
@@ -179,7 +196,7 @@ class View {
                 const partHtml = await this.#render(`./view/${key}/${viewPath}.html`)
                 const titleMatch = partHtml.match(TITLE_REGEX)
                 if (titleMatch && titleMatch[1]) {
-                  title = titleMatch[1]
+                  title = titleMatch[1].trim()
                   break
                 }
               } catch (e) {
@@ -202,6 +219,7 @@ class View {
 
       this.#odac.Request.end({
         output: output,
+        parts: currentParts,
         variables: variables,
         data: this.#odac.Request.sharedData,
         title: title,
@@ -239,6 +257,9 @@ class View {
             }
           }
       }
+
+      // Clean up unresolved skeleton placeholders
+      result = result.replace(/\{\{\s*[A-Z_]+\s*\}\}/g, '')
     }
 
     if (result) {
@@ -294,7 +315,8 @@ class View {
       }
 
       if (attrs.get) {
-        return `{{ get('${attrs.get}') || '' }}`
+        const escaped = attrs.get.replace(/\\/g, '\\\\').replace(/'/g, "\\'")
+        return attrs.raw ? `{!! get('${escaped}') || '' !!}` : `{{ get('${escaped}') || '' }}`
       } else if (attrs.var) {
         if (attrs.raw) {
           return `{!! ${attrs.var} !!}`
@@ -323,7 +345,8 @@ class View {
         }
 
         if (attrs.get) {
-          return `{{ get('${attrs.get}') || '' }}`
+          const escaped = attrs.get.replace(/\\/g, '\\\\').replace(/'/g, "\\'")
+          return attrs.raw ? `{!! get('${escaped}') || '' !!}` : `{{ get('${escaped}') || '' }}`
         } else if (attrs.var) {
           if (attrs.raw) {
             return `{!! ${attrs.var} !!}`
@@ -350,8 +373,9 @@ class View {
             return `%s${placeholderIndex++}`
           })
 
+          const escapedContent = processedContent.replace(/\\/g, '\\\\').replace(/'/g, "\\'")
           const translationCall =
-            placeholders.length > 0 ? `__('${processedContent}', ${placeholders.join(', ')})` : `__('${processedContent}')`
+            placeholders.length > 0 ? `__('${escapedContent}', ${placeholders.join(', ')})` : `__('${escapedContent}')`
 
           if (attrs.raw) {
             return `{!! ${translationCall} !!}`
@@ -359,7 +383,7 @@ class View {
             return `{{ ${translationCall} }}`
           }
         } else {
-          return `{{ '${innerContent}' }}`
+          return `{{ '${innerContent.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}' }}`
         }
       })
       if (before === content) break
@@ -523,8 +547,12 @@ class View {
 
   // - SET PARTS
   set(...args) {
-    if (args.length === 1 && typeof args[0] === 'object') for (let key in args[0]) this.#part[key] = args[0][key]
-    else if (args.length === 2) this.#part[args[0]] = args[1]
+    if (args.length === 1 && typeof args[0] === 'object') {
+      for (let key in args[0]) this.#part[key] = args[0][key]
+    } else if (args.length >= 2) {
+      this.#part[args[0]] = args[1]
+      if (args[2]?.refresh) this.#refresh.add(args[0])
+    }
 
     if (!this.#odac.Request.page) {
       this.#odac.Request.page = this.#part.content || this.#part.all || ''
@@ -541,11 +569,32 @@ class View {
   }
 
   #addNavigateAttribute(skeleton) {
-    skeleton = skeleton.replace(/(<[^>]+>)(\s*\{\{\s*CONTENT\s*\}\})/, (match, openTag, content) => {
-      if (openTag.includes('data-odac-navigate')) return match
-      const tagWithAttr = openTag.slice(0, -1) + ' data-odac-navigate="content">'
-      return tagWithAttr + content
-    })
+    // Single-pass regex to inject data-odac-navigate into parent tags or auto-wrap unwrapped placeholders.
+    // Group 1: Opening tag (<tag>)
+    // Group 2: Whitespace between tag and placeholder
+    // Group 3: Placeholder ({{ PART_NAME }})
+    // Group 4: Part name inside wrapped placeholder
+    // Group 5: Standalone/Unwrapped placeholder
+    // Group 6: Part name inside unwrapped placeholder
+    skeleton = skeleton.replace(
+      /(<(?!\/)[^>]+>)(\s*)(\{\{\s*([A-Z_]+)\s*\}\})|(\{\{\s*([A-Z_]+)\s*\}\})/g,
+      (match, openTag, spaces, wrappedPlaceholder, wrappedPartName, unwrappedPlaceholder, unwrappedPartName) => {
+        if (openTag) {
+          // Case 1: Placeholder immediately follows an opening tag. Inject attribute into the tag.
+          const attrName = wrappedPartName.toLowerCase()
+          const tagWithAttr = openTag.includes('data-odac-navigate') ? openTag : openTag.slice(0, -1) + ` data-odac-navigate="${attrName}">`
+          return `${tagWithAttr}${spaces}${wrappedPlaceholder}`
+        }
+
+        if (unwrappedPlaceholder) {
+          // Case 2: Placeholder is unwrapped (e.g. sibling to a closing tag). Wrap in display:contents.
+          const attrName = unwrappedPartName.toLowerCase()
+          return `<div style="display:contents" data-odac-navigate="${attrName}">${unwrappedPlaceholder}</div>`
+        }
+
+        return match
+      }
+    )
 
     const skeletonName = this.#part.skeleton || 'main'
     const pageName = this.#odac.Request.page || ''
@@ -558,6 +607,17 @@ class View {
       if (!attrs.includes('data-odac-page')) {
         updates.push(`data-odac-page="${pageName}"`)
       }
+
+      // Embed current parts manifest for client-side diffing on first load
+      const partsMap = {}
+      for (let key in this.#part) {
+        if (['all', 'skeleton'].includes(key)) continue
+        if (this.#part[key]) partsMap[key] = this.#part[key]
+      }
+      if (!attrs.includes('data-odac-parts') && Object.keys(partsMap).length > 0) {
+        updates.push(`data-odac-parts='${JSON.stringify(partsMap)}'`)
+      }
+
       if (updates.length === 0) return match
       return `<html${attrs} ${updates.join(' ')}>`
     })

package/test/Database/ConnectionFactory/buildConnections.test.js

@@ -6,6 +6,10 @@ jest.mock(
       mockKnex(...args)
 )
 
+jest.mock('mysql2', () => ({}), {virtual: true})
+jest.mock('pg', () => ({}), {virtual: true})
+jest.mock('sqlite3', () => ({}), {virtual: true})
+
 const {buildConnections} = require('../../../src/Database/ConnectionFactory')
 
 describe('ConnectionFactory.buildConnections()', () => {

package/test/View/addNavigateAttribute.test.js

@@ -0,0 +1,53 @@
+const fs = require('fs').promises
+const path = require('path')
+const View = require('../../src/View')
+
+describe('View.#addNavigateAttribute()', () => {
+  let view
+  let mockOdac
+
+  beforeEach(() => {
+    global.__dir = path.resolve(__dirname, '../../')
+    mockOdac = {
+      Config: {view: {earlyHints: {enabled: false}}},
+      View: {},
+      Request: {
+        req: {url: '/test'},
+        res: {finished: false},
+        isAjaxLoad: false,
+        header: jest.fn(),
+        end: jest.fn(),
+        get: jest.fn(),
+        hasEarlyHints: jest.fn().mockReturnValue(false)
+      },
+      Lang: {get: jest.fn()}
+    }
+    view = new View(mockOdac)
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+    delete global.__dir
+  })
+
+  it('should not wrap placeholder in display:contents if it is the first child of an element', async () => {
+    const skeletonDir = path.join(global.__dir, 'skeleton')
+    const contentDir = path.join(global.__dir, 'view/content/pages')
+    await fs.mkdir(skeletonDir, {recursive: true})
+    await fs.mkdir(contentDir, {recursive: true})
+
+    await fs.writeFile(path.join(skeletonDir, 'main.html'), '<main id="app-main">\n  {{ CONTENT }}\n</main>')
+    await fs.writeFile(path.join(contentDir, 'test.html'), '<h1>Content</h1>')
+
+    view.skeleton('main').set({content: 'pages/test'})
+
+    await view.print()
+
+    expect(mockOdac.Request.end).toHaveBeenCalled()
+    const outputHtml = mockOdac.Request.end.mock.calls[0][0]
+
+    expect(outputHtml).toContain('<main id="app-main" data-odac-navigate="content">')
+    expect(outputHtml).toContain('<h1>Content</h1>')
+    expect(outputHtml).not.toContain('<div style="display:contents"')
+  })
+})

package/test/View/parseOdacTag.test.js

@@ -0,0 +1,180 @@
+const fs = require('fs')
+const fsPromises = fs.promises
+const path = require('path')
+const View = require('../../src/View')
+
+const FIXTURE_DIR = path.resolve(__dirname, '_fixtures')
+
+/**
+ * Integration tests for the #parseOdacTag private method.
+ * Since #parseOdacTag is private, we test it indirectly through the
+ * full render pipeline by creating temporary .html view files,
+ * invoking View.print(), and asserting the rendered output.
+ */
+describe('View.#parseOdacTag()', () => {
+  let originalDir
+  let originalCwd
+
+  beforeAll(async () => {
+    await fsPromises.mkdir(path.join(FIXTURE_DIR, 'skeleton'), {recursive: true})
+    await fsPromises.mkdir(path.join(FIXTURE_DIR, 'view', 'content'), {recursive: true})
+  })
+
+  afterAll(async () => {
+    await fsPromises.rm(FIXTURE_DIR, {recursive: true, force: true})
+  })
+
+  beforeEach(() => {
+    originalDir = global.__dir
+    originalCwd = process.cwd()
+    global.__dir = FIXTURE_DIR
+    process.chdir(FIXTURE_DIR)
+
+    if (global.Odac?.View?.cache) {
+      global.Odac.View.cache = {}
+    }
+    if (global.Odac?.View?.skeletons) {
+      global.Odac.View.skeletons = {}
+    }
+
+    // Clear require cache for compiled templates
+    for (const key of Object.keys(require.cache)) {
+      if (key.includes('.cache')) {
+        delete require.cache[key]
+      }
+    }
+  })
+
+  afterEach(() => {
+    global.__dir = originalDir
+    process.chdir(originalCwd)
+  })
+
+  let testCounter = 0
+
+  /**
+   * Writes a view file, triggers render via print(), and captures output.
+   * Uses a unique filename per call to avoid cache collisions between tests.
+   * Returns the rendered HTML string.
+   */
+  async function renderTemplate(templateContent) {
+    const uniqueId = `test_${++testCounter}`
+    const viewFile = path.join(FIXTURE_DIR, 'view', 'content', `${uniqueId}.html`)
+    await fsPromises.writeFile(viewFile, templateContent, 'utf8')
+
+    const skeletonFile = path.join(FIXTURE_DIR, 'skeleton', 'main.html')
+    await fsPromises.writeFile(skeletonFile, '{{ CONTENT }}', 'utf8')
+
+    let capturedOutput = ''
+    const errors = []
+    const originalError = console.error
+    console.error = (...args) => errors.push(args.join(' '))
+
+    const mockOdac = {
+      Config: {debug: true},
+      Var: value => {
+        const str = value === null || value === undefined ? '' : String(value)
+        return {
+          html: () => str.replace(/[&<>"']/g, m => ({'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'})[m])
+        }
+      },
+      Request: {
+        req: {url: '/test'},
+        res: {finished: false, headersSent: false},
+        isAjaxLoad: false,
+        ajaxLoad: [],
+        variables: {},
+        sharedData: {},
+        page: '',
+        get: () => '',
+        header: () => {},
+        end: output => {
+          capturedOutput = output
+        },
+        hasEarlyHints: () => false,
+        setEarlyHints: () => {}
+      },
+      Lang: {
+        get: (...args) => args[0]
+      },
+      View: {}
+    }
+
+    try {
+      const view = new View(mockOdac)
+      view.skeleton('main')
+      view.set('content', uniqueId)
+      await view.print()
+    } finally {
+      console.error = originalError
+    }
+
+    if (errors.length > 0) {
+      throw new Error(`Template render error: ${errors.join('\n')}`)
+    }
+
+    return capturedOutput
+  }
+
+  describe('single quote escaping in <odac> tags', () => {
+    it('should render a single quote inside <odac> without syntax error', async () => {
+      const result = await renderTemplate("<odac>'</odac>")
+      // Single quotes are HTML-escaped by Odac.Var().html()
+      expect(result).toContain('&#39;')
+    })
+
+    it('should render text with embedded single quotes', async () => {
+      const result = await renderTemplate("<odac>it's working</odac>")
+      expect(result).toContain('it&#39;s working')
+    })
+
+    it('should render multiple single quotes', async () => {
+      const result = await renderTemplate("<odac>it's a developer's life</odac>")
+      expect(result).toContain('it&#39;s a developer&#39;s life')
+    })
+
+    it('should render escaped apostrophe in translation tags', async () => {
+      const result = await renderTemplate("<odac t>it's translated</odac>")
+      expect(result).toContain('it&#39;s translated')
+    })
+  })
+
+  describe('basic <odac> tag rendering', () => {
+    it('should render plain text inside <odac> tags', async () => {
+      const result = await renderTemplate('<odac>hello world</odac>')
+      expect(result).toContain('hello world')
+    })
+
+    it('should strip backend comments (multi-line)', async () => {
+      const result = await renderTemplate('visible<!--odac hidden odac-->visible2')
+      expect(result).toContain('visible')
+      expect(result).toContain('visible2')
+      expect(result).not.toContain('hidden')
+    })
+
+    it('should strip backend comments (single-line)', async () => {
+      const result = await renderTemplate('visible<!--odac hidden -->visible2')
+      expect(result).toContain('visible')
+      expect(result).toContain('visible2')
+      expect(result).not.toContain('hidden')
+    })
+
+    it('should handle empty <odac> tags gracefully', async () => {
+      const result = await renderTemplate('<odac></odac>')
+      expect(typeof result).toBe('string')
+    })
+  })
+
+  describe('special characters in <odac> tags', () => {
+    it('should handle double quotes inside <odac> tags', async () => {
+      const result = await renderTemplate('<odac>say "hello"</odac>')
+      expect(result).toContain('say')
+    })
+
+    it('should handle angle brackets in text (HTML entities)', async () => {
+      const result = await renderTemplate('<odac>&lt;div&gt;</odac>')
+      // Already-escaped entities get double-escaped by Odac.Var().html()
+      expect(result).toContain('&amp;lt;div&amp;gt;')
+    })
+  })
+})

package/test/View/print.test.js

@@ -1,3 +1,5 @@
+const fs = require('fs').promises
+const path = require('path')
 const View = require('../../src/View')
 
 describe('View.print()', () => {
@@ -5,15 +7,57 @@ describe('View.print()', () => {
   let mockOdac
 
   beforeEach(() => {
+    global.__dir = path.resolve(__dirname, '../../')
     mockOdac = {
       Config: {view: {earlyHints: {enabled: false}}},
       View: {},
-      Request: {data: {all: {}}}
+      Request: {
+        req: {url: '/test'},
+        res: {finished: false},
+        isAjaxLoad: false,
+        header: jest.fn(),
+        end: jest.fn(),
+        get: jest.fn(),
+        hasEarlyHints: jest.fn().mockReturnValue(false)
+      },
+      Lang: {get: jest.fn()}
     }
     view = new View(mockOdac)
   })
 
+  afterEach(() => {
+    jest.restoreAllMocks()
+    delete global.__dir
+  })
+
   it('should be a function', () => {
     expect(typeof view.print).toBe('function')
   })
+
+  describe('AJAX Rendering Edge Cases', () => {
+    it("should extract title from priority parts even if their view path hasn't changed", async () => {
+      const headDir = path.join(global.__dir, 'view/head/inc')
+      const contentDir = path.join(global.__dir, 'view/content/pages')
+      await fs.mkdir(headDir, {recursive: true})
+      await fs.mkdir(contentDir, {recursive: true})
+
+      await fs.writeFile(path.join(headDir, 'head.html'), '<title>Dynamic Title</title>')
+      await fs.writeFile(path.join(contentDir, 'test.html'), '<h1>Test</h1>')
+
+      mockOdac.Request.isAjaxLoad = true
+      mockOdac.Request.ajaxLoad = ['head', 'content']
+      mockOdac.Request.clientParts = {head: 'inc/head'}
+      mockOdac.Request.page = 'test_page'
+
+      view.set({head: 'inc/head', content: 'pages/test'})
+
+      await view.print()
+
+      expect(mockOdac.Request.end).toHaveBeenCalled()
+
+      const payload = mockOdac.Request.end.mock.calls[0][0]
+      expect(payload.output.head).toBeUndefined()
+      expect(payload.title).toBe('Dynamic Title')
+    })
+  })
 })

package/test/View/tags.test.js

@@ -0,0 +1,132 @@
+const fs = require('fs')
+const fsPromises = fs.promises
+const path = require('path')
+const View = require('../../src/View')
+
+const FIXTURE_DIR = path.resolve(__dirname, '_fixtures_get')
+
+describe('View odac tags (var, get, translate) raw attribute', () => {
+  let originalDir
+  let originalCwd
+
+  beforeAll(async () => {
+    await fsPromises.mkdir(path.join(FIXTURE_DIR, 'skeleton'), {recursive: true})
+    await fsPromises.mkdir(path.join(FIXTURE_DIR, 'view', 'content'), {recursive: true})
+  })
+
+  afterAll(async () => {
+    await fsPromises.rm(FIXTURE_DIR, {recursive: true, force: true})
+  })
+
+  beforeEach(() => {
+    originalDir = global.__dir
+    originalCwd = process.cwd()
+    global.__dir = FIXTURE_DIR
+    process.chdir(FIXTURE_DIR)
+
+    if (global.Odac?.View?.cache) {
+      global.Odac.View.cache = {}
+    }
+    if (global.Odac?.View?.skeletons) {
+      global.Odac.View.skeletons = {}
+    }
+
+    for (const key of Object.keys(require.cache)) {
+      if (key.includes('.cache')) {
+        delete require.cache[key]
+      }
+    }
+  })
+
+  afterEach(() => {
+    global.__dir = originalDir
+    process.chdir(originalCwd)
+  })
+
+  let testCounter = 0
+
+  async function renderTemplate(templateContent, getValues = {}) {
+    const uniqueId = `test_get_${++testCounter}`
+    const viewFile = path.join(FIXTURE_DIR, 'view', 'content', `${uniqueId}.html`)
+    await fsPromises.writeFile(viewFile, templateContent, 'utf8')
+
+    const skeletonFile = path.join(FIXTURE_DIR, 'skeleton', 'main.html')
+    await fsPromises.writeFile(skeletonFile, '{{ CONTENT }}', 'utf8')
+
+    let capturedOutput = ''
+    const mockOdac = {
+      Config: {debug: true},
+      Var: value => {
+        const str = value === null || value === undefined ? '' : String(value)
+        return {
+          html: () => str.replace(/[&<>"']/g, m => ({'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'})[m])
+        }
+      },
+      Request: {
+        get: key => getValues[key] || '',
+        req: {url: '/test'},
+        res: {finished: false, headersSent: false},
+        isAjaxLoad: false,
+        ajaxLoad: [],
+        variables: {},
+        sharedData: {},
+        page: '',
+        header: () => {},
+        end: output => {
+          capturedOutput = output
+        },
+        hasEarlyHints: () => false,
+        setEarlyHints: () => {}
+      },
+      Lang: {
+        get: (...args) => args[0]
+      },
+      View: {}
+    }
+
+    const view = new View(mockOdac)
+    view.skeleton('main')
+    view.set('content', uniqueId)
+    await view.print()
+
+    return capturedOutput
+  }
+
+  it('should escape <odac get> by default', async () => {
+    const result = await renderTemplate('<odac get="html" />', {html: '<b>bold</b>'})
+    expect(result).toContain('&lt;b&gt;bold&lt;/b&gt;')
+    expect(result).not.toContain('<b>')
+  })
+
+  it('should not escape <odac get> when raw attribute is present (self-closing)', async () => {
+    const result = await renderTemplate('<odac get="html" raw />', {html: '<b>bold</b>'})
+    expect(result).toContain('<b>bold</b>')
+  })
+
+  it('should not escape <odac get> when raw attribute is present (block-level)', async () => {
+    const result = await renderTemplate('<odac get="html" raw></odac>', {html: '<b>bold</b>'})
+    expect(result).toContain('<b>bold</b>')
+  })
+
+  it('should handle missing parameters gracefully with raw', async () => {
+    const result = await renderTemplate('<odac get="missing" raw />', {})
+    expect(result).toContain('data-odac-navigate="content"')
+    expect(result).toContain('id="odac-data"')
+  })
+
+  it('should not escape <odac translate> when raw attribute is present', async () => {
+    const result = await renderTemplate('<odac translate raw><b>bold</b></odac>')
+    expect(result).toContain('<b>bold</b>')
+    expect(result).not.toContain('&lt;b&gt;')
+  })
+
+  it('should escape <odac var> by default', async () => {
+    const result = await renderTemplate('<script:odac>var htmlVar = "<em>test</em>";</script:odac><odac var="htmlVar" />')
+    expect(result).toContain('&lt;em&gt;test&lt;/em&gt;')
+  })
+
+  it('should not escape <odac var> when raw attribute is present', async () => {
+    const result = await renderTemplate('<script:odac>var htmlVar = "<em>test</em>";</script:odac><odac var="htmlVar" raw />')
+    expect(result).toContain('<em>test</em>')
+  })
+})