@aerobuilt/config 0.1.0

package/README.md

@@ -0,0 +1,71 @@
+# @aerobuilt/config
+
+Typed Aero configuration and Vite config factory. Used by `aero.config.ts` and the dev/build entry to produce the final Vite config (Aero plugin, optional content plugin, and user overrides).
+
+## Exports
+
+| Export | Description |
+|--------|-------------|
+| `defineConfig(config)` | Typed helper for `aero.config.ts`. Accepts a static `AeroConfig` or `AeroConfigFunction`. Returns the config unchanged (for IDE/type inference). |
+| `createViteConfig(aeroConfig, options)` | Builds the Vite `UserConfig` from Aero config and env (`command`, `mode`). Merges defaults, Aero + content plugins, and user `vite`; preserves base `minify`/`cssMinify` when user sets them. |
+| `AeroConfig`, `AeroConfigFunction`, `AeroUserConfig` | TypeScript types for config shape and env-aware function. |
+
+## Config shape (`AeroConfig`)
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `content` | `boolean \| AeroContentOptions` | Enable content collections. `true` or options (e.g. `config` path). |
+| `server` | `boolean` | Enable Nitro server integration (default: `false`). |
+| `site` | `string` | Canonical site URL (e.g. `'https://example.com'`). Exposed as `import.meta.env.SITE` and `Aero.site` in templates; used for sitemap, RSS, canonical links. |
+| `dirs` | `object` | Overrides: `client`, `serverDir`, `dist`. |
+| `vite` | `UserConfig` | Vite config merged with Aero defaults. |
+
+## Usage
+
+**aero.config.ts**
+
+```ts
+import { defineConfig } from 'aerobuilt/config'
+
+export default defineConfig({
+	content: true,
+	server: true,
+	site: 'https://example.com', // optional; for sitemap, RSS, canonical URLs
+	dirs: { client: 'client', dist: 'dist' },
+	vite: { build: { target: 'esnext' } },
+})
+```
+
+**Config as a function (env-aware)**
+
+```ts
+import { defineConfig } from 'aerobuilt/config'
+
+export default defineConfig(({ command, mode }) => ({
+	content: true,
+	server: mode === 'production',
+	vite: command === 'build' ? { build: { minify: true } } : {},
+}))
+```
+
+**vite.config.ts (build entry)**
+
+```ts
+import { createViteConfig } from 'aerobuilt/config'
+import aeroConfig from './aero.config'
+
+export default createViteConfig(aeroConfig, {
+	command: process.argv.includes('build') ? 'build' : 'dev',
+	mode: (process.env.NODE_ENV as 'development' | 'production') || 'development',
+})
+```
+
+## Defaults
+
+`createViteConfig` uses a base Vite config from the package: PostCSS (autoprefixer), `build.cssMinify: 'esbuild'`, and rolldown `checks.eval: false`. The Aero plugin (`aero()`) from `aerobuilt/vite` is always included; the content plugin (`aeroContent()`) from `@aerobuilt/content/vite` is added when `content` is enabled.
+
+## Peer dependencies
+
+- `vite` ^8.0.0  
+- `@aerobuilt/core` (workspace)  
+- `@aerobuilt/content` (workspace)

package/dist/index.d.ts

@@ -0,0 +1,85 @@
+import { UserConfig } from 'vite';
+import { AeroContentOptions } from '@aerobuilt/content/vite';
+import { RedirectRule, AeroMiddleware } from '@aerobuilt/core/types';
+export { redirectsToRouteRules } from '@aerobuilt/core/utils/redirects';
+
+/**
+ * Aero config types: user config shape, env-aware function, and resolved config with env.
+ *
+ * @remarks
+ * Used by `aero.config.ts` and by `createViteConfig` to build the final Vite config.
+ */
+
+/** User-facing Aero configuration (content, server, dirs, redirects, middleware, optional Vite overrides). */
+interface AeroConfig {
+    /** Enable content collections (default: `false`). Pass `true` or `AeroContentOptions`. */
+    content?: boolean | AeroContentOptions;
+    /** Enable Nitro server integration (default: `false`). */
+    server?: boolean;
+    /**
+     * Canonical site URL (e.g. `'https://example.com'`). Exposed as `import.meta.env.SITE` and
+     * `Aero.site` in templates; used for sitemap, RSS, and canonical links.
+     */
+    site?: string;
+    /** Directory overrides. */
+    dirs?: {
+        /** Site source directory; pages live at `client/pages` (default: `'client'`). */
+        client?: string;
+        /** Nitro server directory (default: `'server'`). */
+        serverDir?: string;
+        /** Build output directory (default: `'dist'`). */
+        dist?: string;
+    };
+    /**
+     * Redirect rules applied in dev and when using the Nitro server (preview:api / production).
+     * For static-only deploys use host redirect config (_redirects, vercel.json, etc.).
+     */
+    redirects?: RedirectRule[];
+    /**
+     * Request-time middleware (rewrites, custom responses). Runs in dev only.
+     * For redirects use `redirects` so they apply in dev and server.
+     */
+    middleware?: AeroMiddleware[];
+    /** Vite configuration merged with Aero defaults (plugins, build, etc.). */
+    vite?: UserConfig;
+}
+/** Config as a function of env (command, mode); allows different settings for dev vs build. */
+type AeroConfigFunction = (env: {
+    command: 'dev' | 'build';
+    mode: 'development' | 'production';
+}) => AeroConfig;
+/** Either a static config object or a function that returns config. */
+type AeroUserConfig = AeroConfig | AeroConfigFunction;
+
+/**
+ * Typed helper for aero.config.ts: provides type inference and IDE support for the config object or function.
+ */
+
+/**
+ * Define the Aero config (object or function). Pass-through; used for typing and editor support.
+ *
+ * @param config - Static `AeroConfig` or `AeroConfigFunction` receiving `{ command, mode }`.
+ * @returns The same config (unchanged).
+ */
+declare function defineConfig(config: AeroUserConfig): AeroUserConfig;
+
+/** Environment passed to createViteConfig (command and mode). */
+interface CreateViteConfigOptions {
+    command: 'dev' | 'build';
+    mode: 'development' | 'production';
+}
+/** Derive command and mode from argv/NODE_ENV. Use with createViteConfig(aeroConfig, getDefaultOptions()). */
+declare function getDefaultOptions(): CreateViteConfigOptions;
+/**
+ * Create the Vite UserConfig from Aero config and env.
+ *
+ * When called with no arguments, loads aero.config.ts (or .js/.mjs) from process.cwd() if present;
+ * otherwise uses empty config. Command and mode are derived from argv and NODE_ENV.
+ *
+ * @param aeroConfigOrOptions - Optional: static config, config function, or options. Omit to auto-load aero.config.
+ * @param options - Optional when first arg is config. Command and mode (defaults from argv/NODE_ENV when using no-arg form).
+ * @returns Merged Vite config (defaults + Aero plugins + user vite; minify/cssMinify preserved when user overrides).
+ */
+declare function createViteConfig(aeroConfigOrOptions?: AeroConfig | AeroConfigFunction | CreateViteConfigOptions, options?: CreateViteConfigOptions): UserConfig;
+
+export { type AeroConfig, type AeroConfigFunction, type AeroUserConfig, createViteConfig, defineConfig, getDefaultOptions };

package/dist/index.js

@@ -0,0 +1,133 @@
+// src/defineConfig.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/createViteConfig.ts
+import { mergeConfig } from "vite";
+import { aero } from "@aerobuilt/core/vite";
+import { aeroContent } from "@aerobuilt/content/vite";
+
+// src/defaults.ts
+import autoprefixer from "autoprefixer";
+var defaultViteConfig = {
+  css: {
+    postcss: {
+      plugins: [autoprefixer()]
+    }
+  },
+  build: {
+    cssMinify: "esbuild",
+    rolldownOptions: {
+      checks: {
+        eval: false
+      }
+    }
+  }
+};
+
+// src/loadAeroConfig.ts
+import { createRequire } from "module";
+import { existsSync } from "fs";
+import path from "path";
+var require2 = createRequire(import.meta.url);
+var CONFIG_NAMES = ["aero.config.ts", "aero.config.js", "aero.config.mjs"];
+function loadAeroConfig(root) {
+  for (const name of CONFIG_NAMES) {
+    const filePath = path.join(root, name);
+    if (!existsSync(filePath)) continue;
+    try {
+      const jiti = require2("jiti")(root, { esmResolve: true });
+      const relativePath = "./" + name;
+      const mod = jiti(relativePath);
+      const config = mod?.default ?? mod;
+      if (config && (typeof config === "object" || typeof config === "function")) {
+        return config;
+      }
+    } catch (err) {
+      if (process.env.DEBUG?.includes("aero")) {
+        console.error("[createViteConfig] loadAeroConfig failed for", filePath, err);
+      }
+    }
+  }
+  return null;
+}
+
+// src/createViteConfig.ts
+function getDefaultOptions() {
+  return {
+    command: process.argv.includes("build") ? "build" : "dev",
+    mode: process.env.NODE_ENV === "production" ? "production" : "development"
+  };
+}
+function createViteConfig(aeroConfigOrOptions, options) {
+  let aeroConfig;
+  let opts;
+  const isOptionsObject = (x) => typeof x === "object" && x !== null && "command" in x && "mode" in x;
+  const hasExplicitConfig = aeroConfigOrOptions !== void 0 && (typeof aeroConfigOrOptions === "function" || typeof aeroConfigOrOptions === "object" && !isOptionsObject(aeroConfigOrOptions));
+  if (hasExplicitConfig) {
+    aeroConfig = aeroConfigOrOptions;
+    opts = options ?? getDefaultOptions();
+  } else {
+    opts = isOptionsObject(aeroConfigOrOptions) ? aeroConfigOrOptions : getDefaultOptions();
+    const loaded = loadAeroConfig(process.cwd());
+    aeroConfig = loaded ?? {};
+  }
+  return createViteConfigFromAero(aeroConfig, opts);
+}
+function createViteConfigFromAero(aeroConfig, options) {
+  const resolvedConfig = typeof aeroConfig === "function" ? aeroConfig({ command: options.command, mode: options.mode }) : aeroConfig;
+  const {
+    content,
+    server,
+    site,
+    dirs,
+    redirects,
+    middleware,
+    vite: userViteConfig
+  } = resolvedConfig;
+  const contentOptions = content === true ? {} : typeof content === "object" ? content : void 0;
+  const basePlugins = [
+    aero({
+      nitro: server ?? false,
+      site,
+      dirs,
+      redirects,
+      middleware,
+      staticServerPlugins: contentOptions !== void 0 ? [aeroContent(contentOptions)] : void 0
+    })
+  ];
+  if (contentOptions !== void 0) {
+    basePlugins.push(aeroContent(contentOptions));
+  }
+  const baseConfig = {
+    ...defaultViteConfig,
+    plugins: basePlugins
+  };
+  if (!userViteConfig) {
+    return baseConfig;
+  }
+  const merged = mergeConfig(baseConfig, userViteConfig);
+  if (merged.build) {
+    if (merged.build.minify === true || merged.build.minify === null) {
+      if (baseConfig.build?.minify !== void 0) {
+        merged.build.minify = baseConfig.build.minify;
+      }
+    }
+    if (merged.build.cssMinify === true || merged.build.cssMinify === null) {
+      if (baseConfig.build?.cssMinify !== void 0) {
+        merged.build.cssMinify = baseConfig.build.cssMinify;
+      }
+    }
+  }
+  return merged;
+}
+
+// src/redirects.ts
+import { redirectsToRouteRules } from "@aerobuilt/core/utils/redirects";
+export {
+  createViteConfig,
+  defineConfig,
+  getDefaultOptions,
+  redirectsToRouteRules
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@aerobuilt/config",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "author": "Jamie Wilson",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aerobuilt/aero.git",
+    "directory": "packages/config"
+  },
+  "homepage": "https://github.com/aerobuilt/aero",
+  "private": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "autoprefixer": "^10.4.24",
+    "jiti": "^2.4.2"
+  },
+  "peerDependencies": {
+    "vite": "^8.0.0",
+    "@aerobuilt/core": "0.1.0",
+    "@aerobuilt/content": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean --out-dir dist",
+    "typecheck": "tsc --noEmit"
+  }
+}