astro 2.0.10 → 2.0.12

package/dist/cli/check/index.js

@@ -8,8 +8,8 @@ import { fileURLToPath, pathToFileURL } from "url";
 import { printDiagnostic } from "./print.js";
 async function check(settings, { logging }) {
   console.log(bold("astro check"));
-  const { sync } = await import("../sync/index.js");
-  const syncRet = await sync(settings, { logging, fs });
+  const { syncCli } = await import("../../core/sync/index.js");
+  const syncRet = await syncCli(settings, { logging, fs });
   if (syncRet === 1)
     return syncRet;
   const root = settings.config.root;

package/dist/cli/index.js

@@ -161,8 +161,8 @@ async function runCommand(cmd, flags) {
       return process.exit(ret);
     }
     case "sync": {
-      const { sync } = await import("./sync/index.js");
-      const ret = await sync(settings, { logging, fs });
+      const { syncCli } = await import("../core/sync/index.js");
+      const ret = await syncCli(settings, { logging, fs });
       return process.exit(ret);
     }
     case "preview": {

package/dist/content/server-listeners.js

@@ -1,6 +1,8 @@
-import { cyan } from "kleur/colors";
-import { pathToFileURL } from "node:url";
-import { info } from "../core/logger/core.js";
+import { bold, cyan } from "kleur/colors";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { loadTSConfig } from "../core/config/tsconfig.js";
+import { info, warn } from "../core/logger/core.js";
 import { appendForwardSlash } from "../core/path.js";
 import { createContentTypesGenerator } from "./types-generator.js";
 import { getContentPaths, globalContentConfigObserver } from "./utils.js";
@@ -10,7 +12,10 @@ async function attachContentServerListeners({
   logging,
   settings
 }) {
-  const contentPaths = getContentPaths(settings.config);
+  const contentPaths = getContentPaths(settings.config, fs);
+  const maybeTsConfigStats = getTSConfigStatsWhenAllowJsFalse({ contentPaths, settings });
+  if (maybeTsConfigStats)
+    warnAllowJsIsFalse({ ...maybeTsConfigStats, logging });
   if (fs.existsSync(contentPaths.contentDir)) {
     info(
       logging,
@@ -60,6 +65,45 @@ async function attachContentServerListeners({
     );
   }
 }
+function warnAllowJsIsFalse({
+  logging,
+  tsConfigFileName,
+  contentConfigFileName
+}) {
+  if (!["info", "warn"].includes(logging.level))
+    warn(
+      logging,
+      "content",
+      `Make sure you have the ${bold("allowJs")} compiler option set to ${bold(
+        "true"
+      )} in your ${bold(tsConfigFileName)} file to have autocompletion in your ${bold(
+        contentConfigFileName
+      )} file.
+See ${bold("https://www.typescriptlang.org/tsconfig#allowJs")} for more information.
+			`
+    );
+}
+function getTSConfigStatsWhenAllowJsFalse({
+  contentPaths,
+  settings
+}) {
+  var _a, _b;
+  const isContentConfigJsFile = [".js", ".mjs"].some(
+    (ext) => contentPaths.config.url.pathname.endsWith(ext)
+  );
+  if (!isContentConfigJsFile)
+    return;
+  const inputConfig = loadTSConfig(fileURLToPath(settings.config.root), false);
+  const tsConfigFileName = inputConfig.exists && inputConfig.path.split(path.sep).pop();
+  if (!tsConfigFileName)
+    return;
+  const contentConfigFileName = contentPaths.config.url.pathname.split(path.sep).pop();
+  const allowJSOption = (_b = (_a = inputConfig == null ? void 0 : inputConfig.config) == null ? void 0 : _a.compilerOptions) == null ? void 0 : _b.allowJs;
+  const hasAllowJs = allowJSOption === true || tsConfigFileName === "jsconfig.json" && allowJSOption !== false;
+  if (hasAllowJs)
+    return;
+  return { tsConfigFileName, contentConfigFileName };
+}
 export {
   attachContentServerListeners
 };

package/dist/content/types-generator.js

@@ -26,7 +26,7 @@ async function createContentTypesGenerator({
   viteServer
 }) {
   const contentTypes = {};
-  const contentPaths = getContentPaths(settings.config);
+  const contentPaths = getContentPaths(settings.config, fs);
   let events = [];
   let debounceTimeout;
   const contentTypesBase = await fs.promises.readFile(contentPaths.typesTemplate, "utf-8");
@@ -34,7 +34,7 @@ async function createContentTypesGenerator({
     if (!fs.existsSync(contentPaths.contentDir)) {
       return { typesGenerated: false, reason: "no-content-dir" };
     }
-    events.push(handleEvent({ name: "add", entry: contentPaths.config }, { logLevel: "warn" }));
+    events.push(handleEvent({ name: "add", entry: contentPaths.config.url }, { logLevel: "warn" }));
     const globResult = await glob("**", {
       cwd: fileURLToPath(contentPaths.contentDir),
       fs: {
@@ -43,7 +43,7 @@ async function createContentTypesGenerator({
       }
     });
     const entries = globResult.map((e) => new URL(e, contentPaths.contentDir)).filter(
-      (e) => !e.href.startsWith(contentPaths.config.href)
+      (e) => !e.href.startsWith(contentPaths.config.url.href)
     );
     for (const entry of entries) {
       events.push(handleEvent({ name: "add", entry }, { logLevel: "warn" }));
@@ -263,7 +263,7 @@ async function writeContentFiles({
     fs.mkdirSync(contentPaths.cacheDir, { recursive: true });
   }
   let configPathRelativeToCacheDir = normalizePath(
-    path.relative(contentPaths.cacheDir.pathname, contentPaths.config.pathname)
+    path.relative(contentPaths.cacheDir.pathname, contentPaths.config.url.pathname)
   );
   if (!isRelativePath(configPathRelativeToCacheDir))
     configPathRelativeToCacheDir = "./" + configPathRelativeToCacheDir;

package/dist/content/utils.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import matter from 'gray-matter';
-import type fsMod from 'node:fs';
+import fsMod from 'node:fs';
 import { ViteDevServer } from 'vite';
 import { z } from 'zod';
 import { AstroConfig, AstroSettings } from '../@types/astro.js';
@@ -103,7 +103,10 @@ export type ContentPaths = {
     cacheDir: URL;
     typesTemplate: URL;
     virtualModTemplate: URL;
-    config: URL;
+    config: {
+        exists: boolean;
+        url: URL;
+    };
 };
-export declare function getContentPaths({ srcDir, root, }: Pick<AstroConfig, 'root' | 'srcDir'>): ContentPaths;
+export declare function getContentPaths({ srcDir, root }: Pick<AstroConfig, 'root' | 'srcDir'>, fs?: typeof fsMod): ContentPaths;
 export {};

package/dist/content/utils.js

@@ -1,11 +1,11 @@
 import { slug as githubSlug } from "github-slugger";
 import matter from "gray-matter";
+import fsMod from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { normalizePath } from "vite";
 import { z } from "zod";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
-import { appendForwardSlash } from "../core/path.js";
 import { contentFileExts, CONTENT_TYPES_FILE } from "./consts.js";
 const collectionConfigParser = z.object({
   schema: z.any().optional()
@@ -104,22 +104,20 @@ function getEntryInfo({
   return res;
 }
 function getEntryType(entryPath, paths) {
-  const { dir: rawDir, ext, base } = path.parse(entryPath);
-  const dir = appendForwardSlash(pathToFileURL(rawDir).href);
-  const fileUrl = new URL(base, dir);
-  if (hasUnderscoreInPath(fileUrl) || isOnIgnoreList(fileUrl)) {
+  const { ext, base } = path.parse(entryPath);
+  const fileUrl = pathToFileURL(entryPath);
+  if (hasUnderscoreInPath(fileUrl) || isOnIgnoreList(base)) {
     return "ignored";
   } else if (contentFileExts.includes(ext)) {
     return "content";
-  } else if (fileUrl.href === paths.config.href) {
+  } else if (fileUrl.href === paths.config.url.href) {
     return "config";
   } else {
     return "unsupported";
   }
 }
-function isOnIgnoreList(fileUrl) {
-  const { base } = path.parse(fileURLToPath(fileUrl));
-  return [".DS_Store"].includes(base);
+function isOnIgnoreList(fileName) {
+  return [".DS_Store"].includes(fileName);
 }
 function hasUnderscoreInPath(fileUrl) {
   const parts = fileUrl.pathname.split("/");
@@ -172,13 +170,13 @@ async function loadContentConfig({
   settings,
   viteServer
 }) {
-  const contentPaths = getContentPaths(settings.config);
+  const contentPaths = getContentPaths(settings.config, fs);
   let unparsedConfig;
-  if (!fs.existsSync(contentPaths.config)) {
+  if (!contentPaths.config.exists) {
     return void 0;
   }
   try {
-    const configPathname = fileURLToPath(contentPaths.config);
+    const configPathname = fileURLToPath(contentPaths.config.url);
     unparsedConfig = await viteServer.ssrLoadModule(configPathname);
   } catch (e) {
     throw e;
@@ -212,19 +210,28 @@ function contentObservable(initialCtx) {
     subscribe
   };
 }
-function getContentPaths({
-  srcDir,
-  root
-}) {
+function getContentPaths({ srcDir, root }, fs = fsMod) {
+  const configStats = search(fs, srcDir);
   const templateDir = new URL("../../src/content/template/", import.meta.url);
   return {
     cacheDir: new URL(".astro/", root),
     contentDir: new URL("./content/", srcDir),
     typesTemplate: new URL("types.d.ts", templateDir),
     virtualModTemplate: new URL("virtual-mod.mjs", templateDir),
-    config: new URL("./content/config.ts", srcDir)
+    config: configStats
   };
 }
+function search(fs, srcDir) {
+  const paths = ["config.mjs", "config.js", "config.ts"].map(
+    (p) => new URL(`./content/${p}`, srcDir)
+  );
+  for (const file of paths) {
+    if (fs.existsSync(file)) {
+      return { exists: true, url: file };
+    }
+  }
+  return { exists: false, url: paths[0] };
+}
 export {
   NoCollectionError,
   collectionConfigParser,

package/dist/content/vite-plugin-content-imports.js

@@ -21,7 +21,7 @@ function astroContentImportPlugin({
   fs,
   settings
 }) {
-  const contentPaths = getContentPaths(settings.config);
+  const contentPaths = getContentPaths(settings.config, fs);
   return {
     name: "astro:content-imports",
     async load(id) {

package/dist/core/build/index.js

@@ -54,7 +54,7 @@ class AstroBuilder {
       { settings: this.settings, logging, mode: "build" }
     );
     await runHookConfigDone({ settings: this.settings, logging });
-    const { sync } = await import("../../cli/sync/index.js");
+    const { sync } = await import("../sync/index.js");
     const syncRet = await sync(this.settings, { logging, fs });
     if (syncRet !== 0) {
       return process.exit(syncRet);

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "2.0.10";
+const ASTRO_VERSION = "2.0.12";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/dev/dev.js

@@ -5,7 +5,7 @@ import * as msg from "../messages.js";
 import { startContainer } from "./container.js";
 import { createContainerWithAutomaticRestart } from "./restart.js";
 async function dev(settings, options) {
-  var _a, _b;
+  var _a, _b, _c;
   const devStart = performance.now();
   await options.telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({
@@ -14,6 +14,7 @@ async function dev(settings, options) {
     beforeRestart: () => console.clear(),
     params: {
       settings,
+      root: (_a = options.flags) == null ? void 0 : _a.root,
       logging: options.logging,
       isRestart: options.isRestart
     }
@@ -30,11 +31,11 @@ async function dev(settings, options) {
       isRestart: options.isRestart
     })
   );
-  const currentVersion = "2.0.10";
+  const currentVersion = "2.0.12";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }
-  if (((_b = (_a = restart.container.viteConfig.server) == null ? void 0 : _a.fs) == null ? void 0 : _b.strict) === false) {
+  if (((_c = (_b = restart.container.viteConfig.server) == null ? void 0 : _b.fs) == null ? void 0 : _c.strict) === false) {
     warn(options.logging, null, msg.fsStrictWarning());
   }
   await attachContentServerListeners(restart.container);

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.0.10";
+  const version = "2.0.12";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -233,7 +233,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"2.0.10"}`
+        `v${"2.0.12"}`
       )} ${headline}`
     );
   }

package/dist/core/render/dev/environment.js

@@ -14,7 +14,7 @@ function createDevelopmentEnvironment(settings, logging, loader) {
     },
     mode,
     renderers: [],
-    resolve: createResolve(loader),
+    resolve: createResolve(loader, settings.config.root),
     routeCache: new RouteCache(logging, mode),
     site: settings.config.site,
     ssr: settings.config.output === "server",

package/dist/core/render/dev/resolve.d.ts

@@ -1,2 +1,2 @@
 import type { ModuleLoader } from '../../module-loader/index';
-export declare function createResolve(loader: ModuleLoader): (s: string) => Promise<string>;
+export declare function createResolve(loader: ModuleLoader, root: URL): (s: string) => Promise<string>;

package/dist/core/render/dev/resolve.js

@@ -1,8 +1,8 @@
 import { resolveIdToUrl } from "../../util.js";
-function createResolve(loader) {
+function createResolve(loader, root) {
   return async function(s) {
-    const url = await resolveIdToUrl(loader, s);
-    if (url.startsWith("/@fs") && url.endsWith(".jsx")) {
+    const url = await resolveIdToUrl(loader, s, root);
+    if (url.startsWith("/") && url.endsWith(".jsx")) {
       return url.slice(0, -4);
     } else {
       return url;

package/dist/core/sync/index.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import type fsMod from 'node:fs';
+import type { AstroSettings } from '../../@types/astro';
+import { LogOptions } from '../logger/core.js';
+type ProcessExit = 0 | 1;
+export declare function syncCli(settings: AstroSettings, { logging, fs }: {
+    logging: LogOptions;
+    fs: typeof fsMod;
+}): Promise<ProcessExit>;
+export declare function sync(settings: AstroSettings, { logging, fs }: {
+    logging: LogOptions;
+    fs: typeof fsMod;
+}): Promise<ProcessExit>;
+export {};

package/dist/{cli → core}/sync/index.js

@@ -3,11 +3,20 @@ import { performance } from "node:perf_hooks";
 import { createServer } from "vite";
 import { createContentTypesGenerator } from "../../content/index.js";
 import { globalContentConfigObserver } from "../../content/utils.js";
-import { getTimeStat } from "../../core/build/util.js";
-import { createVite } from "../../core/create-vite.js";
-import { AstroError, AstroErrorData } from "../../core/errors/index.js";
-import { info } from "../../core/logger/core.js";
+import { runHookConfigSetup } from "../../integrations/index.js";
 import { setUpEnvTs } from "../../vite-plugin-inject-env-ts/index.js";
+import { getTimeStat } from "../build/util.js";
+import { createVite } from "../create-vite.js";
+import { AstroError, AstroErrorData } from "../errors/index.js";
+import { info } from "../logger/core.js";
+async function syncCli(settings, { logging, fs }) {
+  const resolvedSettings = await runHookConfigSetup({
+    settings,
+    logging,
+    command: "build"
+  });
+  return sync(resolvedSettings, { logging, fs });
+}
 async function sync(settings, { logging, fs }) {
   const timerStart = performance.now();
   const tempViteServer = await createServer(
@@ -51,5 +60,6 @@ async function sync(settings, { logging, fs }) {
   return 0;
 }
 export {
-  sync
+  sync,
+  syncCli
 };

package/dist/core/util.d.ts

@@ -42,7 +42,7 @@ export declare function emoji(char: string, fallback: string): string;
  * Simulate Vite's resolve and import analysis so we can import the id as an URL
  * through a script tag or a dynamic import as-is.
  */
-export declare function resolveIdToUrl(loader: ModuleLoader, id: string): Promise<string>;
+export declare function resolveIdToUrl(loader: ModuleLoader, id: string, root?: URL): Promise<string>;
 export declare function resolveJsToTs(filePath: string): string;
 /**
  * Resolve the hydration paths so that it can be imported in the client

package/dist/core/util.js

@@ -117,7 +117,7 @@ function relativeToSrcDir(config, idOrUrl) {
 function emoji(char, fallback) {
   return process.platform !== "win32" ? char : fallback;
 }
-async function resolveIdToUrl(loader, id) {
+async function resolveIdToUrl(loader, id, root) {
   let resultId = await loader.resolveId(id, void 0);
   if (!resultId && id.endsWith(".jsx")) {
     resultId = await loader.resolveId(id.slice(0, -4), void 0);
@@ -126,7 +126,12 @@ async function resolveIdToUrl(loader, id) {
     return VALID_ID_PREFIX + id;
   }
   if (path.isAbsolute(resultId)) {
-    return "/@fs" + prependForwardSlash(resultId);
+    const normalizedRoot = root && normalizePath(fileURLToPath(root));
+    if (normalizedRoot && resultId.startsWith(normalizedRoot)) {
+      return resultId.slice(normalizedRoot.length - 1);
+    } else {
+      return "/@fs" + prependForwardSlash(resultId);
+    }
   }
   return VALID_ID_PREFIX + resultId;
 }

package/dist/runtime/server/render/common.js

@@ -50,12 +50,19 @@ function stringifyChunk(result, chunk) {
             }
             break;
           }
-          case ScopeFlags.Slot: {
+          case ScopeFlags.Slot:
+          case ScopeFlags.Slot | ScopeFlags.HeadBuffer: {
             if (hasScopeFlag(result, ScopeFlags.RenderSlot)) {
               return "";
             }
             break;
           }
+          case ScopeFlags.HeadBuffer: {
+            if (hasScopeFlag(result, ScopeFlags.JSX | ScopeFlags.HeadBuffer)) {
+              return "";
+            }
+            break;
+          }
           case ScopeFlags.RenderSlot | ScopeFlags.Astro:
           case ScopeFlags.RenderSlot | ScopeFlags.Astro | ScopeFlags.JSX:
           case ScopeFlags.RenderSlot | ScopeFlags.Astro | ScopeFlags.JSX | ScopeFlags.HeadBuffer: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.0.10",
+  "version": "2.0.12",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",

package/dist/cli/sync/index.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="node" />
-import type fsMod from 'node:fs';
-import type { AstroSettings } from '../../@types/astro';
-import { LogOptions } from '../../core/logger/core.js';
-export declare function sync(settings: AstroSettings, { logging, fs }: {
-    logging: LogOptions;
-    fs: typeof fsMod;
-}): Promise<0 | 1>;