@nextsparkjs/theme-default 0.1.0-beta.17 → 0.1.0-beta.170

package/tests/cypress/support/doc-commands.ts

@@ -0,0 +1,260 @@
+/**
+ * Documentation Commands for Cypress
+ *
+ * Custom commands for generating documentation videos with narration.
+ * Uses cypress-slow-down for controlled execution speed.
+ *
+ * @example
+ * // In your test file:
+ * import '../support/doc-commands'
+ *
+ * describe('Tutorial: Login', { tags: ['@doc'] }, () => {
+ *   before(() => {
+ *     cy.startDocMode(800)
+ *   })
+ *
+ *   it('shows how to login', () => {
+ *     cy.narrate('First, navigate to the login page')
+ *     cy.visit('/login')
+ *   })
+ * })
+ */
+
+import { slowCypressDown } from 'cypress-slow-down'
+import 'cypress-slow-down/commands'
+
+// Store narrations for extraction
+interface NarrationEntry {
+  timestamp: number
+  time: string        // "M:SS" format from start (for subtitles)
+  timeMs: number      // Milliseconds from start
+  stepNumber: number
+  text: string
+  highlight?: string
+  duration: number
+  chapter?: string
+}
+
+let narrations: NarrationEntry[] = []
+let stepCounter = 0
+let docModeActive = false
+let startTime = 0     // Timestamp when recording started
+
+/**
+ * Format milliseconds to M:SS or MM:SS string
+ */
+function formatTime(ms: number): string {
+  const totalSeconds = Math.floor(ms / 1000)
+  const minutes = Math.floor(totalSeconds / 60)
+  const seconds = totalSeconds % 60
+  return `${minutes}:${seconds.toString().padStart(2, '0')}`
+}
+
+// Declare custom commands
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Start documentation mode with specified delay between commands
+       * @param delayMs - Milliseconds to wait between each command (default: 800)
+       */
+      startDocMode(delayMs?: number): Chainable<void>
+
+      /**
+       * End documentation mode and save narrations
+       */
+      endDocMode(): Chainable<void>
+
+      /**
+       * Add narration text for the current step
+       * @param text - The narration text to display/speak
+       * @param options - Optional settings like highlight selector
+       */
+      narrate(text: string, options?: { highlight?: string; pause?: number }): Chainable<void>
+
+      /**
+       * Add a chapter/section marker in the narration
+       * @param title - Chapter title
+       */
+      chapter(title: string): Chainable<void>
+
+      /**
+       * Pause for emphasis (used after important actions)
+       * @param ms - Milliseconds to pause
+       */
+      pauseForEmphasis(ms?: number): Chainable<void>
+
+      /**
+       * Highlight an element visually (adds temporary outline)
+       * @param selector - Element selector to highlight
+       */
+      highlightElement(selector: string): Chainable<void>
+    }
+  }
+}
+
+/**
+ * Calculate reading time based on text length
+ * Average reading speed: ~150-180 words per minute for narration
+ * We use ~4 characters = 1 syllable, ~1.5 syllables/second for clear speech
+ */
+function calculateNarrationDuration(text: string): number {
+  const words = text.split(/\s+/).length
+  const wordsPerSecond = 2.5 // Slow, clear narration speed
+  const baseTime = (words / wordsPerSecond) * 1000
+  // Add minimum time and buffer
+  return Math.max(1500, baseTime + 500)
+}
+
+/**
+ * Start documentation mode - slows down Cypress execution
+ */
+Cypress.Commands.add('startDocMode', (delayMs = 800) => {
+  docModeActive = true
+  narrations = []
+  stepCounter = 0
+  startTime = Date.now()  // Record start time
+
+  // Activate slow mode
+  slowCypressDown(delayMs)
+
+  // Log start marker (visible in video)
+  cy.log('🎬 **DOCUMENTATION MODE STARTED**')
+
+  // Add initial narration entry
+  narrations.push({
+    timestamp: startTime,
+    time: '0:00',
+    timeMs: 0,
+    stepNumber: 0,
+    text: '--- Documentation Recording Started ---',
+    duration: 0,
+  })
+})
+
+/**
+ * End documentation mode and save narrations to file
+ */
+Cypress.Commands.add('endDocMode', () => {
+  if (!docModeActive) return
+
+  cy.log('🎬 **DOCUMENTATION MODE ENDED**')
+
+  // Add final narration entry
+  const now = Date.now()
+  const elapsedMs = now - startTime
+  narrations.push({
+    timestamp: now,
+    time: formatTime(elapsedMs),
+    timeMs: elapsedMs,
+    stepNumber: stepCounter + 1,
+    text: '--- Documentation Recording Ended ---',
+    duration: 0,
+  })
+
+  // Save narrations to file via task
+  const specName = Cypress.spec.name.replace('.cy.ts', '').replace('.cy.js', '')
+  cy.task('saveNarrations', {
+    specName,
+    narrations,
+    totalDuration: formatTime(elapsedMs),
+    totalDurationMs: elapsedMs,
+  }, { log: false })
+
+  cy.log(`🎬 **Total Duration: ${formatTime(elapsedMs)}**`)
+
+  docModeActive = false
+  narrations = []
+  stepCounter = 0
+  startTime = 0
+})
+
+/**
+ * Add narration for current step
+ */
+Cypress.Commands.add('narrate', (text: string, options?: { highlight?: string; pause?: number }) => {
+  stepCounter++
+  const duration = calculateNarrationDuration(text)
+  const now = Date.now()
+  const elapsedMs = now - startTime
+  const timeStr = formatTime(elapsedMs)
+
+  // Store narration data
+  narrations.push({
+    timestamp: now,
+    time: timeStr,
+    timeMs: elapsedMs,
+    stepNumber: stepCounter,
+    text,
+    highlight: options?.highlight,
+    duration,
+  })
+
+  // Visual feedback in Cypress runner (will show in video)
+  cy.log(`🎙️ **[${timeStr}]** ${text}`)
+
+  // If highlight specified, add visual indicator
+  if (options?.highlight) {
+    cy.highlightElement(options.highlight)
+  }
+
+  // Wait for narration duration (so video has time for the narration)
+  const waitTime = options?.pause ?? duration
+  cy.wait(waitTime, { log: false })
+})
+
+/**
+ * Add chapter marker
+ */
+Cypress.Commands.add('chapter', (title: string) => {
+  stepCounter++
+  const now = Date.now()
+  const elapsedMs = now - startTime
+  const timeStr = formatTime(elapsedMs)
+
+  narrations.push({
+    timestamp: now,
+    time: timeStr,
+    timeMs: elapsedMs,
+    stepNumber: stepCounter,
+    text: `=== ${title} ===`,
+    chapter: title,
+    duration: 2000,
+  })
+
+  // Large visual marker
+  cy.log(`📖 **[${timeStr}] ━━━ ${title.toUpperCase()} ━━━**`)
+  cy.wait(2000, { log: false })
+})
+
+/**
+ * Pause for emphasis after important actions
+ */
+Cypress.Commands.add('pauseForEmphasis', (ms = 1500) => {
+  cy.log('⏸️ *pause*')
+  cy.wait(ms, { log: false })
+})
+
+/**
+ * Highlight an element with a visual indicator
+ */
+Cypress.Commands.add('highlightElement', (selector: string) => {
+  cy.get(selector).then($el => {
+    // Add highlight class
+    $el.css({
+      outline: '3px solid #ff6b6b',
+      outlineOffset: '2px',
+      transition: 'outline 0.3s ease',
+    })
+
+    // Remove highlight after a delay
+    cy.wait(800, { log: false }).then(() => {
+      $el.css({
+        outline: 'none',
+        outlineOffset: '0',
+      })
+    })
+  })
+})
+
+export {}

package/tests/cypress/support/e2e.ts

@@ -0,0 +1,90 @@
+/**
+ * Cypress E2E Support File for Theme
+ *
+ * This file is used when running tests in npm mode (outside monorepo).
+ * In monorepo mode, the core support file is used instead via cypress.config.ts.
+ *
+ * For documentation video commands, install cypress-slow-down:
+ *   pnpm add -D cypress-slow-down
+ *   Then uncomment the doc-commands import below.
+ */
+
+import '@testing-library/cypress/add-commands'
+
+// Import @cypress/grep for test filtering by tags
+// v5.x uses named export { register }
+import { register as registerCypressGrep } from '@cypress/grep'
+registerCypressGrep()
+
+// Doc commands are optional (require cypress-slow-down)
+// Uncomment if you have cypress-slow-down installed:
+// import './doc-commands'
+
+// Global error handling
+Cypress.on('uncaught:exception', (err) => {
+  // Ignore React hydration errors
+  if (err.message.includes('Hydration')) {
+    return false
+  }
+  // Ignore ResizeObserver errors
+  if (err.message.includes('ResizeObserver')) {
+    return false
+  }
+  return true
+})
+
+// Global before hook
+beforeEach(() => {
+  cy.clearCookies()
+  cy.clearLocalStorage()
+})
+
+// Type declarations for @cypress/grep and custom commands
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Custom command to make API requests with better error handling
+       */
+      apiRequest(options: Partial<Cypress.RequestOptions>): Chainable<Cypress.Response<any>>
+
+      /**
+       * Login command for authenticated tests
+       */
+      login(email: string, password: string): Chainable<void>
+    }
+    interface SuiteConfigOverrides {
+      tags?: string | string[]
+    }
+    interface TestConfigOverrides {
+      tags?: string | string[]
+    }
+  }
+}
+
+// Custom API request command
+Cypress.Commands.add('apiRequest', (options) => {
+  const defaultOptions = {
+    failOnStatusCode: false,
+    timeout: 15000,
+    headers: {
+      'Content-Type': 'application/json',
+      ...options.headers
+    }
+  }
+  return cy.request({
+    ...defaultOptions,
+    ...options
+  })
+})
+
+// Login command for authenticated tests
+Cypress.Commands.add('login', (email: string, password: string) => {
+  cy.session([email, password], () => {
+    cy.visit('/login')
+    cy.get('[data-testid="email-input"], input[name="email"]').type(email)
+    cy.get('[data-testid="password-input"], input[name="password"]').type(password)
+    cy.get('[data-testid="submit-button"], button[type="submit"]').click()
+    cy.url().should('include', '/dashboard')
+  })
+})

package/tests/cypress.config.ts

@@ -0,0 +1,178 @@
+/**
+ * Cypress Configuration for Default Theme
+ *
+ * This config works in both monorepo and npm mode.
+ * Run with: pnpm cy:open or pnpm cy:run
+ *
+ * Filter by tags: pnpm cy:tags "@smoke" or pnpm cy:run --env grepTags="@smoke"
+ */
+
+import { defineConfig } from 'cypress'
+import path from 'path'
+import fs from 'fs'
+import { fileURLToPath } from 'url'
+
+// ESM-compatible __dirname
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+// Paths relative to this config file
+const themeRoot = path.resolve(__dirname, '..')
+const narrationsOutputDir = path.join(__dirname, 'cypress/videos/narrations')
+
+// Detect if running in npm mode vs monorepo
+// In monorepo: themes/default/tests -> 3 levels up to repo root
+// In npm mode: contents/themes/default/tests -> 4 levels up to project root
+const monorepoRoot = path.resolve(__dirname, '../../..')
+const npmRoot = path.resolve(__dirname, '../../../..')
+const isNpmMode = !fs.existsSync(path.join(monorepoRoot, 'packages/core'))
+const projectRoot = isNpmMode ? npmRoot : monorepoRoot
+
+// Load environment variables
+// In monorepo: apps/dev/.env | In npm mode: .env at project root
+import dotenv from 'dotenv'
+const envPath = isNpmMode
+  ? path.join(projectRoot, '.env')
+  : path.join(projectRoot, 'apps/dev/.env')
+dotenv.config({ path: envPath })
+
+// Server port (from .env or default 3000)
+const port = process.env.PORT || 3000
+
+// Extract CYPRESS_ prefixed variables from process.env
+// Cypress auto-strips the CYPRESS_ prefix when accessing via Cypress.env()
+const cypressEnvVars: Record<string, string> = {}
+Object.entries(process.env).forEach(([key, value]) => {
+  if (key.startsWith('CYPRESS_') && value) {
+    // Remove CYPRESS_ prefix for Cypress.env() access
+    const cypressKey = key.replace('CYPRESS_', '')
+    cypressEnvVars[cypressKey] = value
+  }
+})
+
+export default defineConfig({
+  e2e: {
+    // Base URL for the application
+    baseUrl: `http://localhost:${port}`,
+
+    // Spec patterns: theme tests only
+    // Note: core e2e tests were removed as they were empty
+    specPattern: [
+      path.join(__dirname, 'cypress/e2e/**/*.cy.{js,ts}'),
+    ],
+
+    // Support file (always theme-local)
+    supportFile: path.join(__dirname, 'cypress/support/e2e.ts'),
+
+    // Fixtures folder (theme-specific)
+    fixturesFolder: path.join(__dirname, 'cypress/fixtures'),
+
+    // Output folders (theme-specific)
+    downloadsFolder: path.join(__dirname, 'cypress/downloads'),
+    screenshotsFolder: path.join(__dirname, 'cypress/screenshots'),
+    videosFolder: path.join(__dirname, 'cypress/videos'),
+
+    // Viewport settings
+    viewportWidth: 1280,
+    viewportHeight: 720,
+
+    // Video and screenshot settings
+    video: true,
+    screenshotOnRunFailure: true,
+
+    // Timeouts
+    defaultCommandTimeout: 10000,
+    requestTimeout: 10000,
+    responseTimeout: 10000,
+    pageLoadTimeout: 30000,
+
+    // Browser settings
+    chromeWebSecurity: false,
+
+    // Test isolation
+    testIsolation: true,
+
+    // Retry settings
+    retries: {
+      runMode: 1,
+      openMode: 0,
+    },
+
+    // Environment variables
+    env: {
+      // Spread CYPRESS_ prefixed vars from .env (e.g., CYPRESS_DEVELOPER_EMAIL -> DEVELOPER_EMAIL)
+      ...cypressEnvVars,
+
+      // Theme info
+      ACTIVE_THEME: 'default',
+      THEME_PATH: themeRoot,
+
+      // Feature flags
+      ENABLE_ALLURE: true,
+
+      // Allure reporting
+      allureResultsPath: path.join(__dirname, 'cypress/allure-results'),
+
+      // API settings
+      API_URL: `http://localhost:${port}/api`,
+      API_BASE_URL: `http://localhost:${port}`,
+
+      // @cypress/grep - filter specs by tags
+      grepFilterSpecs: true,
+      grepOmitFiltered: true,
+    },
+
+    async setupNodeEvents(on, config) {
+      // Allure plugin setup (allure-cypress)
+      const { allureCypress } = await import('allure-cypress/reporter')
+      allureCypress(on, config, {
+        resultsDir: path.join(__dirname, 'cypress/allure-results'),
+      })
+
+      // @cypress/grep plugin for test filtering by tags
+      // v5.x uses named export { plugin } from '@cypress/grep/plugin'
+      const { plugin: grepPlugin } = await import('@cypress/grep/plugin')
+      grepPlugin(config)
+
+      // Documentation video tasks
+      on('task', {
+        /**
+         * Save narrations to JSON file for post-processing
+         */
+        saveNarrations({ specName, narrations }: { specName: string; narrations: unknown[] }) {
+          // Ensure output directory exists
+          if (!fs.existsSync(narrationsOutputDir)) {
+            fs.mkdirSync(narrationsOutputDir, { recursive: true })
+          }
+
+          const filename = `${specName}-narrations.json`
+          const filepath = path.join(narrationsOutputDir, filename)
+
+          fs.writeFileSync(filepath, JSON.stringify(narrations, null, 2))
+          console.log(`📝 Narrations saved to: ${filepath}`)
+
+          return null
+        },
+
+        /**
+         * Add narration entry (called per narration)
+         */
+        addNarration(narration: unknown) {
+          // This could be used for real-time streaming to a narration service
+          console.log('🎙️ Narration:', narration)
+          return null
+        },
+      })
+
+      return config
+    },
+  },
+
+  // Component testing (future use)
+  component: {
+    devServer: {
+      framework: 'next',
+      bundler: 'webpack',
+    },
+  },
+})

package/tests/jest/__mocks__/@nextsparkjs/core/components/ui/badge.js

@@ -0,0 +1,16 @@
+/**
+ * Mock for @nextsparkjs/core/components/ui/badge
+ */
+const React = require('react')
+
+const Badge = ({ children, variant = 'default', className = '', ...props }) => {
+  return React.createElement('span', {
+    className: `badge badge-${variant} ${className}`.trim(),
+    'data-testid': 'badge',
+    ...props,
+  }, children)
+}
+
+module.exports = { Badge }
+module.exports.Badge = Badge
+module.exports.default = Badge

package/tests/jest/__mocks__/@nextsparkjs/core/lib/db.js

@@ -0,0 +1,11 @@
+/**
+ * Mock for @nextsparkjs/core/lib/db
+ */
+
+const queryWithRLS = jest.fn().mockResolvedValue([])
+const mutateWithRLS = jest.fn().mockResolvedValue({ rowCount: 1 })
+
+module.exports = {
+  queryWithRLS,
+  mutateWithRLS,
+}