@stacksjs/defaults 0.70.207 → 0.70.208

package/assets/world-map-data.ts

@@ -0,0 +1,121 @@
+// This file contains a simplified world map data for ECharts
+// It's a simplified version of the world map GeoJSON data
+
+export const world = {
+  type: 'FeatureCollection' as const,
+  features: [
+    // North America
+    {
+      type: 'Feature' as const,
+      id: 'USA',
+      properties: { name: 'United States of America' },
+      geometry: {
+        type: 'MultiPolygon' as const,
+        coordinates: [[[[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]]]], // Simplified coordinates
+      },
+    },
+    {
+      type: 'Feature' as const,
+      id: 'CAN',
+      properties: { name: 'Canada' },
+      geometry: {
+        type: 'MultiPolygon' as const,
+        coordinates: [[[[0, 10], [10, 10], [10, 20], [0, 20], [0, 10]]]], // Simplified coordinates
+      },
+    },
+    // Europe
+    {
+      type: 'Feature' as const,
+      id: 'DEU',
+      properties: { name: 'Germany' },
+      geometry: {
+        type: 'Polygon' as const,
+        coordinates: [[[-10, 0], [0, 0], [0, 10], [-10, 10], [-10, 0]]], // Simplified coordinates
+      },
+    },
+    {
+      type: 'Feature' as const,
+      id: 'GBR',
+      properties: { name: 'United Kingdom' },
+      geometry: {
+        type: 'MultiPolygon' as const,
+        coordinates: [[[[-15, 5], [-10, 5], [-10, 15], [-15, 15], [-15, 5]]]], // Simplified coordinates
+      },
+    },
+    {
+      type: 'Feature' as const,
+      id: 'FRA',
+      properties: { name: 'France' },
+      geometry: {
+        type: 'MultiPolygon' as const,
+        coordinates: [[[[-15, 0], [-5, 0], [-5, 5], [-15, 5], [-15, 0]]]], // Simplified coordinates
+      },
+    },
+    {
+      type: 'Feature' as const,
+      id: 'ESP',
+      properties: { name: 'Spain' },
+      geometry: {
+        type: 'Polygon' as const,
+        coordinates: [[[-20, -5], [-10, -5], [-10, 0], [-20, 0], [-20, -5]]], // Simplified coordinates
+      },
+    },
+    {
+      type: 'Feature' as const,
+      id: 'NLD',
+      properties: { name: 'Netherlands' },
+      geometry: {
+        type: 'MultiPolygon' as const,
+        coordinates: [[[[-5, 5], [0, 5], [0, 10], [-5, 10], [-5, 5]]]], // Simplified coordinates
+      },
+    },
+    // Asia
+    {
+      type: 'Feature' as const,
+      id: 'IND',
+      properties: { name: 'India' },
+      geometry: {
+        type: 'Polygon' as const,
+        coordinates: [[[20, -10], [30, -10], [30, 0], [20, 0], [20, -10]]], // Simplified coordinates
+      },
+    },
+    {
+      type: 'Feature' as const,
+      id: 'IDN',
+      properties: { name: 'Indonesia' },
+      geometry: {
+        type: 'MultiPolygon' as const,
+        coordinates: [[[[20, -20], [30, -20], [30, -15], [20, -15], [20, -20]]]], // Simplified coordinates
+      },
+    },
+    {
+      type: 'Feature' as const,
+      id: 'JPN',
+      properties: { name: 'Japan' },
+      geometry: {
+        type: 'MultiPolygon' as const,
+        coordinates: [[[[35, 0], [40, 0], [40, 10], [35, 10], [35, 0]]]], // Simplified coordinates
+      },
+    },
+    // Oceania
+    {
+      type: 'Feature' as const,
+      id: 'AUS',
+      properties: { name: 'Australia' },
+      geometry: {
+        type: 'MultiPolygon' as const,
+        coordinates: [[[[20, -30], [30, -30], [30, -20], [20, -20], [20, -30]]]], // Simplified coordinates
+      },
+    },
+    // South America
+    {
+      type: 'Feature' as const,
+      id: 'BRA',
+      properties: { name: 'Brazil' },
+      geometry: {
+        type: 'Polygon' as const,
+        coordinates: [[[-10, -20], [0, -20], [0, -10], [-10, -10], [-10, -20]]], // Simplified coordinates
+      },
+    },
+  ],
+}

package/bootstrap.ts

@@ -0,0 +1,114 @@
+/**
+ * Framework Bootstrap
+ *
+ * Single source of truth for which framework packages are wired into
+ * boot. Each entry below either:
+ *
+ *   1. Imports a framework package whose `index.ts` self-registers via
+ *      `route.register(...)` on import — analogous to the service
+ *      provider pattern other frameworks (competitors) use to give
+ *      packages a chance to wire themselves up at boot. This is the
+ *      preferred shape for packages that own their own routes,
+ *      migrations, etc.
+ *
+ *   2. Registers a framework routes file directly via `route.register()`
+ *      — used when a routes file isn't yet wrapped in its own package.
+ *
+ * Adding a new framework package? Add a line here. There is no
+ * filesystem scanning, no auto-discovery: this file is the entire
+ * grep-able answer to "what does the framework load on boot?".
+ *
+ * @see storage/framework/core/router/src/route-loader.ts:loadFrameworkRoutes
+ */
+
+import { feature } from '@stacksjs/config'
+import { frameworkPath } from '@stacksjs/path'
+import { route } from '@stacksjs/router'
+import MaintenanceMiddleware from './app/Middleware/Maintenance'
+
+// RBAC: wire the bun-query-builder-backed store so `hasRole(user, …)` and
+// friends from `@stacksjs/auth` actually hit the database (otherwise every
+// call throws "RBAC store not configured"). The store is a thin adapter
+// over the `roles` / `permissions` / `user_roles` / `user_permissions` /
+// `role_permissions` tables created by migrations 0000000101–0000000105.
+// Registered unconditionally because the auth middleware + Role middleware
+// both reach for the helpers at request time regardless of which feature
+// the project opts into.
+// DEFERRED, non-blocking wiring on purpose. This file is dynamically
+// imported by the route loader while other entrypoints (a test file, the
+// API server) may still be mid-way through evaluating the @stacksjs/auth
+// async module graph. With a static `import { setRbacStore } ...`, Bun
+// could execute this module against auth's partially-evaluated record:
+// the exported function exists (hoisted) but rbac.ts's module-level
+// `let store` hadn't initialized, so calling it threw
+// `Cannot access 'store' before initialization`, the whole bootstrap
+// import failed, and EVERY framework default route (auth, 2FA, passkeys,
+// dashboard) silently vanished — the loader logs one line and carries
+// on. A blocking `await import('@stacksjs/auth')` here deadlocks instead
+// (auth's evaluation can be waiting on the same route-loading pass that
+// is importing this file), so the wiring is fire-and-forget: routes
+// register immediately, and the RBAC store lands the moment auth's
+// evaluation completes — before any real request needs it.
+import('@stacksjs/auth')
+  .then(({ createBqbRbacStore, setRbacStore }) => setRbacStore(createBqbRbacStore()))
+  .catch(err => console.error('[bootstrap] RBAC store wiring failed:', err))
+
+// Global maintenance / coming-soon gate. Registered first so the
+// `buddy down` / `buddy coming-soon` (and their env-var equivalents)
+// state files intercept every request before any other middleware or
+// route runs.
+//
+// The middleware is a thin wrapper around `maintenanceGate()` in
+// @stacksjs/server, which is also called from the dev server's
+// `onRequest` hook — so dev and prod use one implementation. The gate
+// itself reads `activeSiteModePayload()` so it covers both maintenance
+// and coming-soon modes (plus `APP_MAINTENANCE` / `APP_COMING_SOON`
+// env overrides) without the bootstrap needing to know the details.
+//
+// `toRouterHandler()` adapts the Middleware contract (return void to
+// continue, throw a Response to short-circuit) to bun-router's
+// `(req, next) => Response` shape. Without the adapter, `handle` would
+// return `undefined`, bun-router's chain treats that as a short-circuit
+// to an empty 200, and every route returns `200 OK Content-Length: 0`.
+route.use(MaintenanceMiddleware.toRouterHandler() as any)
+
+// Locale cookie + STX-style path redirect (`/locale/en` → `/en/…`).
+// Overridable by registering the same path in app routes first.
+await route.register(frameworkPath('defaults/routes/core.ts'))
+
+// Feature-gated route registration. The dashboard.ts file currently bundles
+// ~687 lines covering auth, password reset, email subscribe, storefront
+// cart/checkout, reviews, sitemap, AI, voice, and the admin dashboard's
+// REST surface. Until that file is split per-feature (auth.ts, marketing.ts,
+// commerce.ts, monitoring.ts), the whole thing loads when `dashboard` is
+// activated and stays inert otherwise.
+//
+// Apps that need only a slice — e.g. a marketing site that wants
+// `/api/email/subscribe` and `/api/contact` but not the rest — can either
+//   1. Activate `dashboard` and live with the over-broad register; the
+//      action handlers for routes you don't hit never fire, and their
+//      models stay un-loaded as long as the corresponding feature flag
+//      (`commerce`, `cms`, `monitoring`) is off, so there's no hidden
+//      cost beyond the bun-router route-table entries.
+//   2. Define the routes they want directly in `routes/api.ts` —
+//      first-registration-wins means the user version takes priority.
+//
+// Once the per-feature route split lands, each `if (feature('X'))` block
+// below registers just the X-specific routes file.
+if (feature('dashboard')) {
+  await route.register(frameworkPath('defaults/routes/dashboard.ts'))
+  // JSON endpoints for the dev dashboard UI. Kept separate from the view
+  // routes above so the data layer is one obvious file to grep.
+  await route.register(frameworkPath('defaults/routes/dashboard-api.ts'))
+}
+
+// Email webhook + unsubscribe routes (stacksjs/stacks#1881, #1880).
+// Always mounted when the `email` feature is on — the underlying
+// handlers self-disable when their provider credentials aren't
+// configured (they 401 rather than processing). Apps that need a
+// non-default mount path register their own routes in `routes/api.ts`
+// and the framework's mount silently no-ops since user routes
+// register first.
+if (feature('email')) {
+  await route.register(frameworkPath('defaults/routes/email.ts'))
+}

package/docs/api-examples.md

@@ -0,0 +1,46 @@
+---
+title: Runtime Data Examples
+team: Stacks
+outline: deep
+---
+
+# {{ title }}
+
+BunPress exposes frontmatter and files from `docs/.data/` directly to the STX render context. No client framework or runtime composable is required.
+
+## Frontmatter
+
+**Input**
+
+```md
+---
+title: Runtime Data Examples
+team: Stacks
+---
+
+# {{ title }}
+
+Built by {{ team }}.
+```
+
+**Output**
+
+Built by {{ team }}.
+
+## Global data
+
+Add `docs/.data/project.json`:
+
+```json
+{
+  "repository": "stacksjs/stacks"
+}
+```
+
+The object is available as `project` in Markdown and STX expressions:
+
+```md
+Repository: {{ project.repository }}
+```
+
+See the [BunPress data-loading guide](https://github.com/stacksjs/bunpress/blob/main/docs/advanced.md#data-loading) for loaders and build-time data sources.

package/docs/index.md

@@ -0,0 +1,24 @@
+---
+# BunPress home-page frontmatter
+layout: home
+
+hero:
+  name: "Stacks.js"
+  text: "A better developer environment."
+  tagline: A rapid development environment for modern web applications & libraries.
+  actions:
+    - theme: brand
+      text: Markdown Examples
+      link: /markdown-examples
+    - theme: alt
+      text: API Examples
+      link: /api-examples
+
+features:
+  - title: Feature A
+    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
+  - title: Feature B
+    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
+  - title: Feature C
+    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
+---

package/docs/markdown-examples.md

@@ -0,0 +1,87 @@
+# Markdown Extension Examples
+
+This page demonstrates the built-in Markdown extensions provided by BunPress.
+
+## Syntax Highlighting
+
+BunPress provides syntax highlighting powered by [Shiki](https://github.com/shikijs/shiki), with additional features such as line highlighting:
+
+**Input**
+
+````md
+```js{4}
+
+export default {
+  data () {
+    return {
+      msg: 'Highlighted!'
+    }
+  }
+}
+
+```
+````
+
+**Output**
+
+```js{4}
+<script server>
+const message = 'Highlighted!'
+</script>
+
+<template>
+  <p>{{ message }}</p>
+</template>
+```
+
+## Custom Containers
+
+**Input**
+
+```md
+::: info
+This is an info box.
+:::
+
+::: tip
+This is a tip.
+:::
+
+::: warning
+This is a warning.
+:::
+
+::: danger
+This is a dangerous warning.
+:::
+
+::: details
+This is a details block.
+:::
+```
+
+**Output**
+
+::: info
+This is an info box.
+:::
+
+::: tip
+This is a tip.
+:::
+
+::: warning
+This is a warning.
+:::
+
+::: danger
+This is a dangerous warning.
+:::
+
+::: details
+This is a details block.
+:::
+
+## More
+
+See the [BunPress markdown extensions reference](https://github.com/stacksjs/bunpress/blob/main/docs/markdown-extensions.md) for the complete syntax.

package/functions/analytics.ts

@@ -0,0 +1,97 @@
+/**
+ * Analytics Composable
+ */
+import { ref } from '@stacksjs/stx'
+
+const baseUrl = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+
+export interface AnalyticsOverview {
+  realtime: number
+  people: number
+  views: number
+  avgTimeOnSite: string
+  bounceRate: string
+  eventCompletions: number
+}
+
+export interface TrafficDataPoint {
+  date: string
+  visitors: number
+  pageViews: number
+}
+
+export interface PageData {
+  path: string
+  entries: number
+  visitors: number
+  views: number
+  percentage: number
+}
+
+export interface ReferrerData {
+  name: string
+  visitors: number
+  views: number
+  percentage: number
+}
+
+export interface DeviceData {
+  name: string
+  visitors: number
+  percentage: number
+}
+
+export interface BrowserData {
+  name: string
+  visitors: number
+  percentage: number
+}
+
+export interface CountryData {
+  name: string
+  visitors: number
+  percentage: number
+  flag: string
+}
+
+export function useAnalytics() {
+  const overview = ref<AnalyticsOverview>({ realtime: 0, people: 0, views: 0, avgTimeOnSite: '0s', bounceRate: '0%', eventCompletions: 0 })
+  const trafficData = ref<TrafficDataPoint[]>([])
+  const pagesData = ref<PageData[]>([])
+  const referrersData = ref<ReferrerData[]>([])
+  const devicesData = ref<DeviceData[]>([])
+  const browsersData = ref<BrowserData[]>([])
+  const countriesData = ref<CountryData[]>([])
+  const isLoading = ref(false)
+  const error = ref<string | null>(null)
+
+  async function fetchAll(dateRange = '7d') {
+    isLoading.value = true
+    error.value = null
+    try {
+      const response = await fetch(`${baseUrl}/analytics/web?range=${dateRange}`, {
+        headers: { 'Accept': 'application/json' },
+      })
+      if (response.ok) {
+        const data = await response.json()
+        overview.value = data.overview || overview.value
+        trafficData.value = data.traffic || []
+        pagesData.value = data.pages || []
+        referrersData.value = data.referrers || []
+        devicesData.value = data.devices || []
+        browsersData.value = data.browsers || []
+        countriesData.value = data.countries || []
+      }
+    } catch (e) {
+      error.value = 'Failed to load analytics data.'
+      console.error('Failed to fetch analytics:', e)
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  return {
+    overview, trafficData, pagesData, referrersData, devicesData, browsersData, countriesData,
+    isLoading, error, fetchAll,
+  }
+}

package/functions/api.ts

@@ -0,0 +1,143 @@
+/**
+ * API Client for Dashboard
+ *
+ * Provides a simple fetch wrapper with authentication and error handling.
+ */
+
+import { useAuth } from './auth'
+
+const baseUrl = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+
+export interface ApiResponse<T> {
+  data: T
+  message?: string
+}
+
+export interface ApiError {
+  message: string
+  errors?: Record<string, string[]>
+}
+
+/**
+ * Create headers with authentication
+ */
+function createHeaders(contentType = 'application/json'): Headers {
+  const { getToken } = useAuth()
+  const headers = new Headers({
+    'Accept': 'application/json',
+    'Content-Type': contentType,
+  })
+
+  const token = getToken()
+  if (token) {
+    headers.set('Authorization', `Bearer ${token}`)
+  }
+
+  return headers
+}
+
+/**
+ * Handle API response
+ */
+async function handleResponse<T>(response: Response): Promise<T> {
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({
+      message: `HTTP error! status: ${response.status}`,
+    }))
+    throw new Error(error.message || `HTTP error! status: ${response.status}`)
+  }
+
+  return response.json() as Promise<T>
+}
+
+/**
+ * GET request
+ */
+export async function get<T>(endpoint: string): Promise<T> {
+  const response = await fetch(`${baseUrl}${endpoint}`, {
+    method: 'GET',
+    headers: createHeaders(),
+  })
+
+  return handleResponse<T>(response)
+}
+
+/**
+ * POST request
+ */
+export async function post<T>(endpoint: string, body?: unknown): Promise<T> {
+  const response = await fetch(`${baseUrl}${endpoint}`, {
+    method: 'POST',
+    headers: createHeaders(),
+    body: body ? JSON.stringify(body) : undefined,
+  })
+
+  return handleResponse<T>(response)
+}
+
+/**
+ * PUT request
+ */
+export async function put<T>(endpoint: string, body?: unknown): Promise<T> {
+  const response = await fetch(`${baseUrl}${endpoint}`, {
+    method: 'PUT',
+    headers: createHeaders(),
+    body: body ? JSON.stringify(body) : undefined,
+  })
+
+  return handleResponse<T>(response)
+}
+
+/**
+ * PATCH request
+ */
+export async function patch<T>(endpoint: string, body?: unknown): Promise<T> {
+  const response = await fetch(`${baseUrl}${endpoint}`, {
+    method: 'PATCH',
+    headers: createHeaders(),
+    body: body ? JSON.stringify(body) : undefined,
+  })
+
+  return handleResponse<T>(response)
+}
+
+/**
+ * DELETE request
+ */
+export async function del<T>(endpoint: string): Promise<T> {
+  const response = await fetch(`${baseUrl}${endpoint}`, {
+    method: 'DELETE',
+    headers: createHeaders(),
+  })
+
+  return handleResponse<T>(response)
+}
+
+/**
+ * Create a typed API resource helper
+ */
+export function createResource<T>(basePath: string) {
+  return {
+    list: () => get<ApiResponse<T[]>>(basePath),
+    get: (id: string | number) => get<ApiResponse<T>>(`${basePath}/${id}`),
+    create: (data: Partial<T>) => post<ApiResponse<T>>(basePath, data),
+    update: (id: string | number, data: Partial<T>) => put<ApiResponse<T>>(`${basePath}/${id}`, data),
+    patch: (id: string | number, data: Partial<T>) => patch<ApiResponse<T>>(`${basePath}/${id}`, data),
+    delete: (id: string | number) => del<ApiResponse<void>>(`${basePath}/${id}`),
+  }
+}
+
+/**
+ * API composable
+ */
+export function useApi() {
+  return {
+    get,
+    post,
+    put,
+    patch,
+    delete: del,
+    createResource,
+    baseUrl,
+  }
+}