@wix/origami-site 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-site",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Runs an exported Wix origami site: file-based routing, Wix dynamic pages, popups and build checks. Use with @wix/origami-site-astro or @wix/origami-site-express.",
   "type": "module",
   "files": [
@@ -9,12 +9,14 @@
   "scripts": {
     "build": "tsc --noEmit",
     "lint": "oxlint .",
-    "test": "tsc --noEmit -p tsconfig.test.json"
+    "test": "node --test test/*.spec.js && tsc --noEmit -p tsconfig.test.json"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "typescript": "^6.0.3",
-    "vite": "^8"
+    "vite": "^8",
+    "@vitejs/plugin-react": "^5.2.0",
+    "postcss": "^8.5.3"
   },
   "publishUnscoped": false,
   "publishConfig": {
@@ -43,7 +45,9 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "@wix/builder-error-pages": "^1.1.6",
-    "@wix/builder-piler-components": "^1.6.7"
+    "@wix/builder-piler-components": "^1.6.7",
+    "@wix/origami-transforms": "0.1.2",
+    "@babel/parser": "^7.25.0"
   },
   "exports": {
     "./server": {
@@ -58,14 +62,20 @@
       "types": "./src/popups/index.d.ts",
       "default": "./src/popups/index.js"
     },
-    "./vite-plugins": {
-      "types": "./src/vite-plugins/index.d.ts",
-      "default": "./src/vite-plugins/index.js"
+    "./build": {
+      "types": "./src/build/index.d.ts",
+      "default": "./src/build/index.js"
     },
     "./types": {
       "types": "./src/types/index.d.ts"
     },
-    "./default-error-404": "./src/default-error-404.jsx"
+    "./default-error-404": {
+      "types": "./src/default-error-404.d.ts",
+      "default": "./src/default-error-404.jsx"
+    }
+  },
+  "peerDependencies": {
+    "vite": "^8"
   },
-  "falconPackageHash": "88d8479096308cdba298b8fe696e53dbd9a3482bd149a332bd45b100"
+  "falconPackageHash": "c7e37593d4cdf506898d4bc2680d2948adb3027e23c106ffad08d458"
 }

package/src/build/globalImports.js

@@ -0,0 +1,18 @@
+import { existsSync, statSync } from 'node:fs'
+import { dirname, resolve, sep } from 'node:path'
+
+/** @param {string} root
+ * @returns {import('vite').Plugin} */
+export const globalImports = root => ({
+    name: 'origami:global-imports',
+    enforce: /** @type {const} */ ('pre'),
+    resolveId(source, importer) {
+        if (!importer || source === './' || !(source.startsWith('./') || source.startsWith('../'))) return undefined
+        const folder = resolve(dirname(importer.split('?', 1)[0]), source)
+        if (!folder.startsWith(`${resolve(root, 'src/global')}${sep}`)) return undefined
+        const entry = resolve(folder, '_generated/index.jsx')
+        if (existsSync(folder) && statSync(folder).isDirectory() && existsSync(entry) && statSync(entry).isFile())
+            return entry
+        return undefined
+    },
+})

package/src/build/index.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from 'vite'
+import type { OrigamiSite } from '../server/index.js'
+
+export type OrigamiVitePluginsOptions = {
+    /** The site package folder, containing src/pages/, src/global/, and src/site/ glue. */
+    root: string
+    /** Shared with the adapter; the plugins do not scan or own the site tree. */
+    siteTree: Pick<OrigamiSite, 'table' | 'onTableChange'>
+}
+export function origamiVitePlugins(options: OrigamiVitePluginsOptions): Plugin[]

package/src/build/index.js

@@ -0,0 +1,15 @@
+import { transforms } from './transforms.js'
+import { globalImports } from './globalImports.js'
+import { pageList } from './pageList.js'
+import { sharedPackages } from './sharedPackages.js'
+
+/** @param {import('./index.js').OrigamiVitePluginsOptions} options
+ * @returns {import('vite').Plugin[]} */
+export function origamiVitePlugins({ root, siteTree }) {
+    return [
+        globalImports(root),
+        pageList(siteTree),
+        ...transforms({ root }),
+        sharedPackages(),
+    ]
+}

package/src/build/pageList.js

@@ -0,0 +1,37 @@
+const publicId = 'virtual:origami-site'
+const resolvedId = `\0${publicId}`
+
+/** @param {import('@wix/origami-types').SiteRouteTable} table */
+function moduleSource(table) {
+    // itemPath is relative to src/ and already includes the pages/ prefix.
+    const entries = [...table.pages, table.notFound].map(page => {
+        const entry = page.itemPath
+            ? `/src/${page.itemPath}/_generated/index.jsx`
+            : '@wix/origami-site/default-error-404'
+        return `    [${JSON.stringify(page.key)}]: () => import(${JSON.stringify(entry)})`
+    })
+    return `export const pages = {\n${entries.join(',\n')}\n};\nexport const popups = {};\nexport const seoUriByPageId = {};\n`
+}
+
+/** @param {import('./index.js').OrigamiVitePluginsOptions['siteTree']} siteTree
+ * @returns {import('vite').Plugin} */
+export function pageList(siteTree) {
+    /** @type {(() => void) | undefined} */
+    let unsubscribe
+    return {
+        name: 'origami:page-list',
+        resolveId(id) { if (id === publicId) return resolvedId },
+        async load(id) { if (id === resolvedId) return moduleSource(await siteTree.table()) },
+        configureServer(server) {
+            unsubscribe?.()
+            unsubscribe = siteTree.onTableChange(() => {
+                for (const environment of Object.values(server.environments)) {
+                    const module = environment.moduleGraph.getModuleById(resolvedId)
+                    if (module) environment.moduleGraph.invalidateModule(module)
+                }
+                server.ws.send({ type: 'full-reload', path: '*' })
+            })
+        },
+        closeBundle() { unsubscribe?.(); unsubscribe = undefined },
+    }
+}

package/src/build/sharedPackages.js

@@ -0,0 +1,14 @@
+/** @returns {import('vite').Plugin} */
+export function sharedPackages() {
+    return {
+        name: 'origami:shared-packages',
+        config: () => ({ resolve: { dedupe: [
+            'react',
+            'react-dom',
+            '@wix/services-manager-react',
+            '@wix/sdk-react-context',
+            '@preact/signals-react',
+            '@preact/signals-core',
+        ] } }),
+    }
+}

package/src/build/transforms.js

@@ -0,0 +1,27 @@
+import { resolve } from 'node:path'
+import { createTransformPipeline } from '@wix/origami-transforms'
+
+/** @param {{ root: string }} options
+ * @returns {import('vite').Plugin[]} */
+export function transforms({ root }) {
+    const pipeline = createTransformPipeline({ layout: { root: resolve(root) } })
+    return [
+        {
+            name: 'origami:jsx-checks',
+            enforce: 'pre',
+            config(_, { command }) { pipeline.setCommand(command) },
+            transform(code, id, options) {
+                if (pipeline.appliesTo(id, { ssr: options?.ssr })) return pipeline.transformJsx(code, id, { ssr: options?.ssr })
+            },
+        },
+        {
+            name: 'origami:css-transforms',
+            config: () => ({ css: { postcss: { plugins: [pipeline.postcssPlugin] } } }),
+            handleHotUpdate({ file, server }) {
+                if (pipeline.failedStylesheetDependsOn(resolve(file))) {
+                    server.ws.send({ type: 'full-reload', path: '*' })
+                }
+            },
+        },
+    ]
+}

package/src/default-error-404.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentType } from 'react'
+
+declare const DefaultError404: ComponentType
+export default DefaultError404

package/src/default-error-404.jsx

@@ -1,9 +1,4 @@
-import React from 'react'
-import { createRoot } from 'react-dom/client'
 import { DefaultError404 } from '@wix/builder-error-pages'
-import { PilerPage } from '@wix/builder-piler-components'
 import '@wix/builder-error-pages/style.css'
 
-createRoot(document.getElementById('root')).render(
-    React.createElement(React.StrictMode, null, React.createElement(PilerPage, { Page: DefaultError404 }))
-)
+export default DefaultError404

package/src/server/index.d.ts

@@ -70,7 +70,8 @@ export interface AccessHandler {
 }
 
 
-export type { SiteTreeError, RouterServiceError } from './requests/errors.js'
+export { SiteTreeError } from './requests/errors.js'
+export type { RouterServiceError } from './requests/errors.js'
 export function createSite(options: SiteOptions): Promise<OrigamiSite>
 export function readSiteTree(root: string): Promise<SiteRouteTable>
 export function runInRequestContext<T>(ctx: RequestContext, fn: () => Promise<T>): Promise<T>

package/src/server/index.js

@@ -1 +1,2 @@
-export {}
+export { readSiteTree } from './site-tree/readSiteTree.js'
+export { SiteTreeError } from './requests/errors.js'

package/src/server/requests/errors.d.ts

@@ -1,5 +1,6 @@
 export class SiteTreeError extends Error {
   code:
+    | 'NOT_SUPPORTED_YET'                // router pages are not supported in stage 1
     | 'DUPLICATE_URL'                    // two folders give the same URL
     | 'ROUTE_JSON_INVALID'               // not JSON, or a required field missing or of the wrong type
     | 'ROUTE_JSON_MISSING_SERVICE_URL'   // no routerServiceUrl: origami refuses to start
@@ -13,6 +14,7 @@ export class SiteTreeError extends Error {
     | 'NOT_FOUND_HAS_CHILDREN'
     | 'DUPLICATE_POPUP'
     | 'UNSUPPORTED_ACCESS_RULE'          // see section 4
+  constructor(code: SiteTreeError['code'], paths: string[], message: string)
   paths: string[]
 }
 

package/src/server/requests/errors.js

@@ -0,0 +1,13 @@
+export class SiteTreeError extends Error {
+    /**
+     * @param {import('./errors.js').SiteTreeError['code']} code
+     * @param {string[]} paths Paths relative to the site package root.
+     * @param {string} message
+     */
+    constructor(code, paths, message) {
+        super(`SiteTreeError ${code}\n${paths.map(path => `  ${path}`).join('\n')}\n  ${message}`)
+        this.name = 'SiteTreeError'
+        this.code = code
+        this.paths = [...paths]
+    }
+}

package/src/server/site-tree/createSiteTree.js

@@ -0,0 +1,55 @@
+import { relative, resolve, sep } from 'node:path'
+import { readSiteTree, siteRoot } from './readSiteTree.js'
+
+/** Internal live table; adapters supply file events, never a second watcher. */
+export const createSiteTree = root => {
+    const rootPath = siteRoot(root)
+    let dirty = true
+    let closed = false
+    /** @type {Promise<import('@wix/origami-types').SiteRouteTable> | undefined} */
+    let pending
+    /** @type {import('@wix/origami-types').SiteRouteTable | undefined} */
+    let current
+    let signature
+    /** @type {Set<(table: import('@wix/origami-types').SiteRouteTable) => void>} */
+    const listeners = new Set()
+    return {
+        table() {
+            if (closed) return Promise.reject(new Error('Site tree is closed.'))
+            if (dirty) {
+                dirty = false
+                // Serialize rescans, including recovery after a rejected scan.
+                pending = (pending ?? Promise.resolve()).catch(() => {}).then(async () => {
+                    const next = await readSiteTree(rootPath)
+                    const nextSignature = JSON.stringify(next)
+                    if (signature !== nextSignature) {
+                        const hadTable = current !== undefined
+                        current = next
+                        signature = nextSignature
+                        if (hadTable && !closed) for (const listener of listeners) listener(next)
+                    }
+                    return /** @type {import('@wix/origami-types').SiteRouteTable} */ (current)
+                })
+            }
+            return /** @type {Promise<import('@wix/origami-types').SiteRouteTable>} */ (pending)
+        },
+        fileChanged(path) {
+            if (closed) return
+            const changed = resolve(rootPath, path)
+            for (const directory of ['pages', 'popups']) {
+                const suffix = relative(resolve(rootPath, 'src', directory), changed)
+                if (suffix === '' || (suffix !== '..' && !suffix.startsWith(`..${sep}`) && !suffix.startsWith(sep))) dirty = true
+            }
+        },
+        /** @param {(table: import('@wix/origami-types').SiteRouteTable) => void} listener */
+        onTableChange(listener) {
+            if (!closed) listeners.add(listener)
+            return () => { listeners.delete(listener) }
+        },
+        async close() {
+            closed = true
+            listeners.clear()
+            await pending?.catch(() => {})
+        },
+    }
+}

package/src/server/site-tree/readSiteTree.js

@@ -0,0 +1,97 @@
+// Ported from origami-site-runtime/routing/pagesToRoutes.js for the layout 2 tree.
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { basename, resolve } from 'node:path'
+import { parse } from '@babel/parser'
+import { SiteTreeError } from '../requests/errors.js'
+
+/** @type {Map<string, { mtimeMs: number, metadata: { title?: string, pageId?: string } }>} */
+const metadataCache = new Map()
+
+const readMetadata = structure => {
+    const ast = parse(readFileSync(structure, 'utf8'), { sourceType: 'module', plugins: ['jsx'] })
+    /** @type {{ title?: string, pageId?: string }} */
+    const metadata = {}
+    // Walk Babel's AST without a runtime dependency on @babel/types.
+    const visit = node => {
+        if (!node || typeof node !== 'object') return
+        if (node.type === 'JSXOpeningElement' && node.name.type === 'JSXIdentifier' && node.name.name === 'Page') {
+            for (const attribute of node.attributes) {
+                if (attribute.type !== 'JSXAttribute') continue
+                if (attribute.name.name === 'id' && attribute.value?.type === 'StringLiteral' && metadata.pageId === undefined)
+                    metadata.pageId = attribute.value.value
+                if (metadata.title !== undefined || attribute.name.name !== 'data' ||
+                    attribute.value?.type !== 'JSXExpressionContainer' ||
+                    attribute.value.expression.type !== 'ObjectExpression') continue
+                const property = attribute.value.expression.properties.find(candidate =>
+                    candidate.type === 'ObjectProperty' && !candidate.computed &&
+                    ((candidate.key.type === 'Identifier' && candidate.key.name === 'title') ||
+                        (candidate.key.type === 'StringLiteral' && candidate.key.value === 'title')))
+                if (property?.value.type === 'StringLiteral') metadata.title = property.value.value
+            }
+        }
+        for (const value of Object.values(node)) {
+            if (Array.isArray(value)) value.forEach(visit)
+            else if (value && typeof value === 'object') visit(value)
+        }
+    }
+    visit(ast)
+    return metadata
+}
+
+const pageMetadata = folder => {
+    const structure = resolve(folder, 'structure.jsx')
+    const fallback = basename(folder).replace(/^\(([^()]+)\)$/, '$1')
+    if (!existsSync(structure)) {
+        metadataCache.delete(structure)
+        return { title: fallback }
+    }
+    const { mtimeMs } = statSync(structure)
+    let cached = metadataCache.get(structure)
+    if (cached?.mtimeMs !== mtimeMs) {
+        cached = { mtimeMs, metadata: readMetadata(structure) }
+        metadataCache.set(structure, cached)
+    }
+    return { ...cached.metadata, title: cached.metadata.title ?? fallback }
+}
+
+export const siteRoot = root => {
+    if (typeof root !== 'string' || !root) throw new TypeError('root must be a non-empty string.')
+    return resolve(root)
+}
+
+/** @param {string} root @returns {Promise<import('@wix/origami-types').SiteRouteTable>} */
+export const readSiteTree = async root => {
+    const pagesDir = resolve(siteRoot(root), 'src/pages')
+    /** @type {import('@wix/origami-types').PageRoute[]} */
+    const pages = []
+    /** @type {import('@wix/origami-types').SiteNotFoundRoute} */
+    let notFound = { key: '@wix/origami-site/default-error-404', title: 'Page not found' }
+    const pathsByUrl = new Map()
+    const walk = (folder, itemPath) => {
+        const entries = readdirSync(folder, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))
+        const path = `src/${itemPath}`
+        if (/^\[.*\]$/.test(basename(folder)))
+            throw new SiteTreeError('NOT_SUPPORTED_YET', [path], 'Router pages are not supported yet.')
+        if (entries.some(entry => entry.name === 'route.json'))
+            throw new SiteTreeError('NOT_SUPPORTED_YET', [`${path}/route.json`], 'Router pages are not supported yet.')
+        const children = entries.filter(entry => entry.isDirectory() && !entry.name.startsWith('.') &&
+            !['_generated', 'node_modules'].includes(entry.name))
+        if (itemPath === 'pages/error404' && children.length)
+            throw new SiteTreeError('NOT_FOUND_HAS_CHILDREN', [path, ...children.map(child => `${path}/${child.name}`)],
+                'The not-found page cannot have children.')
+        if (entries.some(entry => entry.isFile() && !entry.name.startsWith('.'))) {
+            const metadata = pageMetadata(folder)
+            if (itemPath === 'pages/error404') notFound = { key: itemPath, itemPath, title: metadata.title }
+            else {
+                const url = '/' + itemPath.split('/').slice(1).filter(segment => !/^\([^()]+\)$/.test(segment)).join('/')
+                const previous = pathsByUrl.get(url)
+                if (previous) throw new SiteTreeError('DUPLICATE_URL', [previous, path], `Both pages serve "${url}".`)
+                pathsByUrl.set(url, path)
+                pages.push({ key: itemPath, url, itemPath, ...metadata, access: [] })
+            }
+        }
+        for (const child of children) walk(resolve(folder, child.name), `${itemPath}/${child.name}`)
+    }
+    if (existsSync(pagesDir)) walk(pagesDir, 'pages')
+    return { version: 2, pages, routers: [], notFound, popups: [] }
+}

package/src/vite-plugins/index.d.ts

@@ -1,2 +0,0 @@
-import type { Plugin } from 'vite'
-export function origamiVitePlugins(options: { root: string }): Plugin[]

package/src/vite-plugins/index.js

@@ -1 +0,0 @@
-export {}