vite-wp 0.1.0

package/dist/runtime/wp-config.js

@@ -0,0 +1,82 @@
+import { mkdirSync, symlinkSync, writeFileSync, existsSync, lstatSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { randomBytes } from 'node:crypto';
+export function writeWordPressConfig(config) {
+    const docroot = resolve(config.root, config.wordpress.docroot);
+    const contentDir = resolve(config.root, config.wordpress.contentDir);
+    const wpConfigPath = join(docroot, 'wp-config.php');
+    const publicUrl = config.wordpress.url;
+    mkdirSync(docroot, { recursive: true });
+    mkdirSync(join(contentDir, 'plugins'), { recursive: true });
+    mkdirSync(join(contentDir, 'mu-plugins'), { recursive: true });
+    mkdirSync(join(contentDir, 'uploads'), { recursive: true });
+    ensureContentSymlink(docroot, contentDir);
+    writeFileSync(wpConfigPath, renderWpConfig(config, publicUrl, contentDir), 'utf8');
+    console.log(`✓ wp-config.php generated at ${relative(config.root, wpConfigPath)}`);
+}
+export function phpServerUrl(config) {
+    return `http://${config.dev.phpHost}:${config.dev.phpPort}`;
+}
+function renderWpConfig(config, publicUrl, contentDir) {
+    const database = config.database;
+    return `<?php
+/**
+ * Generated by ViteWP for local development.
+ * Do not edit this file by hand; update vitewp.config.ts or environment variables instead.
+ */
+
+define('DB_NAME', ${phpString(database.name)});
+define('DB_USER', ${phpString(database.user)});
+define('DB_PASSWORD', ${phpString(database.password)});
+define('DB_HOST', ${phpString(`${database.host}:${database.port}`)});
+define('DB_CHARSET', 'utf8mb4');
+define('DB_COLLATE', '');
+
+${authKeys()}
+
+$table_prefix = ${phpString(database.tablePrefix)};
+
+define('WP_DEBUG', true);
+define('WP_DEBUG_DISPLAY', false);
+define('WP_DEBUG_LOG', true);
+@ini_set('display_errors', '0');
+define('WP_ENVIRONMENT_TYPE', 'local');
+define('WP_DEFAULT_THEME', 'vitewp');
+define('WP_HOME', ${phpString(publicUrl)});
+define('WP_SITEURL', ${phpString(publicUrl)});
+define('WP_CONTENT_DIR', ${phpString(contentDir)});
+define('WP_CONTENT_URL', WP_HOME . '/wp-content');
+
+if (! defined('ABSPATH')) {
+    define('ABSPATH', __DIR__ . '/');
+}
+
+require_once ABSPATH . 'wp-settings.php';
+`;
+}
+function authKeys() {
+    const names = [
+        'AUTH_KEY',
+        'SECURE_AUTH_KEY',
+        'LOGGED_IN_KEY',
+        'NONCE_KEY',
+        'AUTH_SALT',
+        'SECURE_AUTH_SALT',
+        'LOGGED_IN_SALT',
+        'NONCE_SALT',
+    ];
+    return names.map((name) => `define('${name}', '${randomBytes(32).toString('base64')}');`).join('\n');
+}
+function phpString(value) {
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+function ensureContentSymlink(docroot, contentDir) {
+    const link = join(docroot, 'wp-content');
+    if (existsSync(link)) {
+        if (lstatSync(link).isSymbolicLink())
+            return;
+        return;
+    }
+    const target = relative(dirname(link), contentDir);
+    symlinkSync(target, link, 'dir');
+}

package/dist/wordpress/client.d.ts

@@ -0,0 +1,98 @@
+export interface WpRenderedField {
+    rendered: string;
+}
+export interface WpContentItem {
+    id: number;
+    slug: string;
+    type: string;
+    link: string;
+    title: WpRenderedField;
+    content: WpRenderedField;
+    excerpt?: WpRenderedField;
+    date?: string;
+    modified?: string;
+}
+export interface WpArchivePayload {
+    items: WpContentItem[];
+    page: number;
+    perPage: number;
+    total: number;
+    totalPages: number;
+}
+interface BaseArchiveResolution {
+    found: true;
+    slug: string;
+    postType: string;
+    restBase: string;
+    title: string;
+    page?: number;
+}
+export type WpBridgeResolution = {
+    found: true;
+    kind: 'page' | 'single';
+    id: number;
+    slug: string;
+    postType: string;
+    restBase: string;
+    isFrontPage?: boolean;
+    isPostsPage?: boolean;
+} | (BaseArchiveResolution & {
+    kind: 'postsArchive' | 'postTypeArchive';
+}) | (BaseArchiveResolution & {
+    kind: 'taxonomyArchive';
+    taxonomy: string;
+    taxonomyRestBase: string;
+    termId: number;
+    termName: string;
+}) | (BaseArchiveResolution & {
+    kind: 'search';
+    search: string;
+}) | {
+    found: false;
+    kind: 'notFound';
+};
+export type WpResolvedRoute = {
+    kind: 'page';
+    postType: 'page';
+    restBase: 'pages';
+    slug: string;
+    item: WpContentItem;
+    isFrontPage?: boolean;
+} | {
+    kind: 'single';
+    postType: string;
+    restBase: string;
+    slug: string;
+    item: WpContentItem;
+} | {
+    kind: 'postsArchive' | 'postTypeArchive' | 'search';
+    postType: string;
+    restBase: string;
+    slug: string;
+    title: string;
+    items: WpContentItem[];
+    page: number;
+    perPage: number;
+    total: number;
+    totalPages: number;
+    search?: string;
+} | {
+    kind: 'taxonomyArchive';
+    postType: string;
+    restBase: string;
+    slug: string;
+    title: string;
+    items: WpContentItem[];
+    page: number;
+    perPage: number;
+    total: number;
+    totalPages: number;
+    taxonomy: string;
+    taxonomyRestBase: string;
+    termId: number;
+    termName: string;
+};
+export declare function resolveWordPressRoute(pathname: string): Promise<WpResolvedRoute | null>;
+export declare function getWordPressApiBase(): string;
+export declare function getWordPressBaseUrl(): string;
+export {};

package/dist/wordpress/client.js

@@ -0,0 +1,133 @@
+export async function resolveWordPressRoute(pathname) {
+    const resolution = await resolveViaWordPress(pathname);
+    if (!resolution.found) {
+        return null;
+    }
+    switch (resolution.kind) {
+        case 'postsArchive':
+        case 'postTypeArchive': {
+            const archive = await getArchive({
+                kind: resolution.kind,
+                postType: resolution.postType,
+                page: resolution.page ?? 1,
+            });
+            return {
+                kind: resolution.kind,
+                postType: resolution.postType,
+                restBase: resolution.restBase,
+                slug: resolution.slug,
+                title: resolution.title,
+                ...archive,
+            };
+        }
+        case 'taxonomyArchive': {
+            const archive = await getArchive({
+                kind: resolution.kind,
+                postType: resolution.postType,
+                taxonomy: resolution.taxonomy,
+                termId: resolution.termId,
+                page: resolution.page ?? 1,
+            });
+            return {
+                kind: 'taxonomyArchive',
+                postType: resolution.postType,
+                restBase: resolution.restBase,
+                slug: resolution.slug,
+                title: resolution.title,
+                taxonomy: resolution.taxonomy,
+                taxonomyRestBase: resolution.taxonomyRestBase,
+                termId: resolution.termId,
+                termName: resolution.termName,
+                ...archive,
+            };
+        }
+        case 'search': {
+            const archive = await getArchive({
+                kind: resolution.kind,
+                search: resolution.search,
+                page: resolution.page ?? 1,
+            });
+            return {
+                kind: 'search',
+                postType: resolution.postType,
+                restBase: resolution.restBase,
+                slug: resolution.slug,
+                title: resolution.title,
+                search: resolution.search,
+                ...archive,
+            };
+        }
+        case 'page':
+        case 'single':
+            break;
+    }
+    if (resolution.isPostsPage) {
+        const archive = await getArchive({ kind: 'postsArchive', postType: 'post', page: 1 });
+        return {
+            kind: 'postsArchive',
+            postType: 'post',
+            restBase: 'posts',
+            slug: resolution.slug,
+            title: '',
+            ...archive,
+        };
+    }
+    const item = await getById(resolution.restBase, resolution.id);
+    if (resolution.kind === 'page') {
+        return {
+            kind: 'page',
+            postType: 'page',
+            restBase: 'pages',
+            slug: resolution.slug,
+            item,
+            isFrontPage: resolution.isFrontPage,
+        };
+    }
+    return {
+        kind: 'single',
+        postType: resolution.postType,
+        restBase: resolution.restBase,
+        slug: resolution.slug,
+        item,
+    };
+}
+export function getWordPressApiBase() {
+    const base = getWordPressBaseUrl();
+    return `${base}/wp-json/wp/v2`;
+}
+export function getWordPressBaseUrl() {
+    return (process.env.VITEWP_PUBLIC_URL ?? process.env.WP_URL ?? 'http://localhost:3000').replace(/\/$/, '');
+}
+async function resolveViaWordPress(pathname) {
+    const url = new URL(`${getWordPressBaseUrl()}/wp-json/vitewp/v1/resolve`);
+    url.searchParams.set('path', pathname || '/');
+    const response = await fetch(url);
+    if (response.status === 404) {
+        return { found: false, kind: 'notFound' };
+    }
+    if (!response.ok) {
+        throw new Error(`ViteWP route resolution failed: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+async function getById(restBase, id) {
+    const url = new URL(`${getWordPressApiBase()}/${restBase}/${id}`);
+    url.searchParams.set('_embed', '1');
+    return getJson(url);
+}
+async function getArchive(params) {
+    const url = new URL(`${getWordPressBaseUrl()}/wp-json/vitewp/v1/archive`);
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined) {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    return getJson(url);
+}
+async function getJson(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`WordPress REST request failed: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}

package/dist/wordpress/generated-types.d.ts

@@ -0,0 +1,33 @@
+export type WpPostType = "post" | "page" | "attachment";
+export type WpTaxonomy = "category" | "post_tag";
+export type WpRestBaseByPostType = {
+    "post": "posts";
+    "page": "pages";
+    "attachment": "media";
+};
+export type WpArchiveSlugByPostType = {
+    "post": null;
+    "page": null;
+    "attachment": null;
+};
+export type WpRestBaseByTaxonomy = {
+    "category": "categories";
+    "post_tag": "tags";
+};
+export interface WpRenderedField {
+    rendered: string;
+    protected?: boolean;
+}
+export interface WpContentItem<PostType extends WpPostType = WpPostType> {
+    id: number;
+    slug: string;
+    type: PostType;
+    link: string;
+    title: WpRenderedField;
+    content: WpRenderedField;
+    excerpt?: WpRenderedField;
+    date?: string;
+    modified?: string;
+}
+export interface WpArchiveItem<PostType extends WpPostType = WpPostType> extends WpContentItem<PostType> {
+}

package/dist/wordpress/generated-types.js

@@ -0,0 +1,2 @@
+// Generated by ViteWP. Do not edit by hand.
+export {};

package/dist/wordpress/menus.d.ts

@@ -0,0 +1,24 @@
+export interface WpMenuItem {
+    id: number;
+    parent: number;
+    title: string;
+    url: string;
+    target: string;
+    classes: string[];
+    object: string;
+    objectId: number;
+    type: string;
+}
+export interface WpMenu {
+    id: number;
+    slug: string;
+    name: string;
+    items: WpMenuItem[];
+}
+export interface WpMenusPayload {
+    locations: Record<string, number>;
+    menus: WpMenu[];
+}
+export declare function getMenus(): Promise<WpMenusPayload>;
+export declare function getMenuByLocation(location: string): Promise<WpMenu | null>;
+export declare function getMenuBySlug(slug: string): Promise<WpMenu | null>;

package/dist/wordpress/menus.js

@@ -0,0 +1,20 @@
+import { getWordPressBaseUrl } from './client.js';
+export async function getMenus() {
+    const response = await fetch(`${getWordPressBaseUrl()}/wp-json/vitewp/v1/menus`);
+    if (!response.ok) {
+        throw new Error(`Could not fetch WordPress menus: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+export async function getMenuByLocation(location) {
+    const payload = await getMenus();
+    const menuId = payload.locations[location];
+    if (!menuId) {
+        return null;
+    }
+    return payload.menus.find((menu) => menu.id === menuId) ?? null;
+}
+export async function getMenuBySlug(slug) {
+    const payload = await getMenus();
+    return payload.menus.find((menu) => menu.slug === slug) ?? null;
+}

package/dist/wordpress/schemas.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'astro/zod';
+export declare const wpRenderedFieldSchema: z.ZodObject<{
+    rendered: z.ZodString;
+    protected: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export declare const wpContentItemSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    slug: z.ZodString;
+    type: z.ZodString;
+    link: z.ZodString;
+    title: z.ZodObject<{
+        rendered: z.ZodString;
+        protected: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>;
+    content: z.ZodObject<{
+        rendered: z.ZodString;
+        protected: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>;
+    excerpt: z.ZodOptional<z.ZodObject<{
+        rendered: z.ZodString;
+        protected: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    date: z.ZodOptional<z.ZodString>;
+    modified: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const wpResolvedRouteSchema: z.ZodObject<{
+    kind: z.ZodString;
+    postType: z.ZodString;
+    restBase: z.ZodString;
+    slug: z.ZodString;
+}, z.core.$loose>;
+export declare const wpMenuItemSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    parent: z.ZodNumber;
+    title: z.ZodString;
+    url: z.ZodString;
+    target: z.ZodString;
+    classes: z.ZodArray<z.ZodString>;
+    object: z.ZodString;
+    objectId: z.ZodNumber;
+    type: z.ZodString;
+}, z.core.$loose>;
+export declare const wpMenuSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    slug: z.ZodString;
+    name: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        parent: z.ZodNumber;
+        title: z.ZodString;
+        url: z.ZodString;
+        target: z.ZodString;
+        classes: z.ZodArray<z.ZodString>;
+        object: z.ZodString;
+        objectId: z.ZodNumber;
+        type: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;

package/dist/wordpress/schemas.js

@@ -0,0 +1,39 @@
+import { z } from 'astro/zod';
+export const wpRenderedFieldSchema = z.looseObject({
+    rendered: z.string(),
+    protected: z.boolean().optional(),
+});
+export const wpContentItemSchema = z.looseObject({
+    id: z.number(),
+    slug: z.string(),
+    type: z.string(),
+    link: z.string(),
+    title: wpRenderedFieldSchema,
+    content: wpRenderedFieldSchema,
+    excerpt: wpRenderedFieldSchema.optional(),
+    date: z.string().optional(),
+    modified: z.string().optional(),
+});
+export const wpResolvedRouteSchema = z.looseObject({
+    kind: z.string(),
+    postType: z.string(),
+    restBase: z.string(),
+    slug: z.string(),
+});
+export const wpMenuItemSchema = z.looseObject({
+    id: z.number(),
+    parent: z.number(),
+    title: z.string(),
+    url: z.string(),
+    target: z.string(),
+    classes: z.array(z.string()),
+    object: z.string(),
+    objectId: z.number(),
+    type: z.string(),
+});
+export const wpMenuSchema = z.looseObject({
+    id: z.number(),
+    slug: z.string(),
+    name: z.string(),
+    items: z.array(wpMenuItemSchema),
+});

package/dist/wordpress/templates.d.ts

@@ -0,0 +1,19 @@
+import type { WpContentItem, WpResolvedRoute } from './client.js';
+export interface TemplateContext {
+    route: WpResolvedRoute;
+    title: string;
+    content: string;
+    excerpt: string;
+    slug: string;
+    postType: string;
+    items: WpContentItem[];
+    page: number;
+    perPage: number;
+    total: number;
+    totalPages: number;
+    search?: string;
+    taxonomy?: string;
+    termName?: string;
+}
+export declare function createTemplateContext(route: WpResolvedRoute): TemplateContext;
+export declare function templateCandidates(route: WpResolvedRoute): string[];

package/dist/wordpress/templates.js

@@ -0,0 +1,88 @@
+export function createTemplateContext(route) {
+    switch (route.kind) {
+        case 'postsArchive':
+        case 'postTypeArchive':
+        case 'search':
+            return {
+                route,
+                title: route.title,
+                content: '',
+                excerpt: '',
+                slug: route.slug,
+                postType: route.postType,
+                items: route.items,
+                page: route.page,
+                perPage: route.perPage,
+                total: route.total,
+                totalPages: route.totalPages,
+                search: route.search,
+            };
+        case 'taxonomyArchive':
+            return {
+                route,
+                title: route.title,
+                content: '',
+                excerpt: '',
+                slug: route.slug,
+                postType: route.postType,
+                items: route.items,
+                page: route.page,
+                perPage: route.perPage,
+                total: route.total,
+                totalPages: route.totalPages,
+                taxonomy: route.taxonomy,
+                termName: route.termName,
+            };
+        case 'page':
+        case 'single':
+            return {
+                route,
+                title: route.item.title.rendered,
+                content: route.item.content.rendered,
+                excerpt: route.item.excerpt?.rendered ?? '',
+                slug: route.slug,
+                postType: route.postType,
+                items: [],
+                page: 1,
+                perPage: 0,
+                total: 0,
+                totalPages: 0,
+            };
+    }
+}
+export function templateCandidates(route) {
+    if (route.kind === 'search') {
+        return ['search.astro', 'posts/archive.astro'];
+    }
+    if (route.kind === 'taxonomyArchive') {
+        return [
+            `taxonomies/${route.taxonomy}-${route.slug}.astro`,
+            `taxonomies/${route.taxonomy}.astro`,
+            'taxonomies/taxonomy-[taxonomy].astro',
+            'posts/archive.astro',
+        ];
+    }
+    if (route.kind === 'postsArchive') {
+        return ['posts/archive.astro'];
+    }
+    if (route.kind === 'postTypeArchive') {
+        return [
+            `post-types/${route.postType}/archive.astro`,
+            'posts/archive.astro',
+        ];
+    }
+    if (route.kind === 'page') {
+        return [
+            ...(route.isFrontPage ? ['pages/front-page.astro'] : []),
+            `pages/page-${route.slug}.astro`,
+            'pages/default.astro',
+        ];
+    }
+    return [
+        `post-types/${route.postType}/single-${route.slug}.astro`,
+        `post-types/${route.postType}/single.astro`,
+        ...(route.postType === 'post' ? [] : ['posts/single.astro']),
+        `posts/single-${route.slug}.astro`,
+        'posts/single.astro',
+    ];
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "vite-wp",
+  "private": false,
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "vitewp": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./astro": {
+      "types": "./dist/astro.d.ts",
+      "import": "./dist/astro.js"
+    },
+    "./content": {
+      "types": "./dist/content.d.ts",
+      "import": "./dist/content.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts dev",
+    "doctor": "tsx src/cli.ts doctor",
+    "build": "rm -rf dist && tsc",
+    "prepack": "npm run build",
+    "pack:dry": "npm pack --dry-run",
+    "publish:npm": "npm publish --access public",
+    "preview": "node dist/cli.js doctor",
+    "astro:dev": "astro dev",
+    "astro:check": "astro check",
+    "types": "tsx src/cli.ts types",
+    "smoke": "tsx src/cli.ts smoke"
+  },
+  "dependencies": {
+    "astro": "^7.0.6",
+    "vite": "^8.1.1"
+  },
+  "devDependencies": {
+    "@astrojs/check": "^0.9.9",
+    "@types/node": "^24.10.2",
+    "tsx": "^4.21.0",
+    "typescript": "~6.0.2"
+  },
+  "description": "Astro-first WordPress development framework with a Composer-managed local WordPress runtime.",
+  "license": "MIT",
+  "author": "Didair",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/didair/vitewp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/didair/vitewp/issues"
+  },
+  "homepage": "https://github.com/didair/vitewp#readme",
+  "keywords": [
+    "wordpress",
+    "astro",
+    "vite",
+    "headless",
+    "php",
+    "composer"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "starter",
+    "README.md",
+    "LICENSE"
+  ],
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  }
+}