@publish.os/nextjs 0.0.1-alpha.90 → 0.0.1-alpha.92

package/compiler-assets/nextjs/shims/site-mdx-components.tsx

@@ -37,51 +37,63 @@ const VideoComponent = (sourceMedia.video ??
 const FigureComponent = (sourceMedia.figure ??
   PublishOsFigure) as typeof PublishOsFigure;
 
-function resolveMediaAsset(src: unknown): ResolvedMediaAsset | undefined {
-  if (typeof src !== "string" || !src.startsWith("/assets/")) return undefined;
-  return mediaManifest.assets[src as keyof typeof mediaManifest.assets] as
-    | ResolvedMediaAsset
-    | undefined;
+function getMediaMetadata(src: unknown): ResolvedMediaAsset | undefined {
+  if (typeof src !== "string") return undefined;
+  const pathname = src.split(/[?#]/u, 1)[0];
+  if (!pathname?.startsWith("/publishos/assets/")) return undefined;
+  return Object.values(
+    mediaManifest.assets as Record<string, ResolvedMediaAsset>,
+  ).find((asset) => asset.outputPath === pathname);
+}
+
+function authoredDimension(value: unknown): number | undefined {
+  if (typeof value === "number") return value;
+  if (typeof value !== "string" || !/^\d+$/u.test(value)) return undefined;
+  const dimension = Number(value);
+  return Number.isSafeInteger(dimension) && dimension > 0
+    ? dimension
+    : undefined;
 }
 
 function Link(props: LinkProps) {
-  const asset = resolveMediaAsset(props.href);
+  const asset = getMediaMetadata(props.href);
   const shouldDownload =
     asset?.mediaType === "document" || asset?.mediaType === "file";
   return (
     <LinkComponent
       {...props}
       download={props.download ?? (shouldDownload ? "" : undefined)}
-      href={asset?.outputPath ?? props.href}
+      href={props.href}
     />
   );
 }
 
 function Image(props: ImageProps) {
-  const asset = resolveMediaAsset(props.src);
+  const asset = getMediaMetadata(props.src);
+  const width = authoredDimension(props.width);
+  const height = authoredDimension(props.height);
   return (
     <ImageComponent
       {...props}
       aspect={props.aspect ?? asset?.aspect}
-      height={props.height ?? asset?.height}
+      height={height ?? asset?.height}
       intrinsicHeight={asset?.intrinsicHeight ?? asset?.height}
       intrinsicWidth={asset?.intrinsicWidth ?? asset?.width}
-      optimized={asset?.optimized}
-      src={asset?.outputPath ?? props.src}
-      width={props.width ?? asset?.width}
+      optimized={props.optimized ?? asset?.optimized}
+      src={props.src}
+      width={width ?? asset?.width}
     />
   );
 }
 
 function Video(props: VideoProps) {
-  const asset = resolveMediaAsset(props.src);
-  const poster = resolveMediaAsset(props.poster);
+  const asset = getMediaMetadata(props.src);
   return (
     <VideoComponent
       {...props}
       height={props.height ?? asset?.height}
-      poster={poster?.outputPath ?? props.poster}
-      src={asset?.outputPath ?? props.src}
+      poster={props.poster}
+      src={props.src}
       width={props.width ?? asset?.width}
     />
   );

package/compiler-assets/nextjs/shims/site-mdx.tsx

@@ -1,12 +1,17 @@
 import type { MDXProps } from "@publish.os/nextjs/mdx/mdx";
 import { renderMdx } from "@publish.os/nextjs/mdx/mdx";
 import { mdxComponents } from "@source/_internal/mdx-components.generated";
+import { importedMdxComponents } from "@source/_internal/mdx-icon-components.generated";
 
 export type { MDXComponents, MDXProps } from "@publish.os/nextjs/mdx/mdx";
 export { Figure, Image, Link, Video } from "@publish.os/nextjs/mdx/mdx";
 
 export async function MDX(props: MDXProps) {
-  return renderMdx({ ...props, siteComponents: mdxComponents });
+  return renderMdx({
+    ...props,
+    siteComponents: mdxComponents,
+    importedComponents: importedMdxComponents[props.page.path],
+  });
 }
 
 Object.defineProperty(MDX, "__publishOsMdx", { value: true });

package/dist/{build-operation-2JAYBSKF.js → build-operation-CJDUL4OW.js}

@@ -1,30 +1,30 @@
+import {
+  approveLocalComposition,
+  installLocalApp
+} from "./chunk-4BC2L2KA.js";
+import {
+  withLocalOperation
+} from "./chunk-IL4RJOKI.js";
 import {
   prepareIdeSupport
-} from "./chunk-UF6ATARM.js";
+} from "./chunk-3T4HVDSC.js";
+import "./chunk-6D2E6UMD.js";
 import {
   composeFrameworkSource
-} from "./chunk-H6XILMZX.js";
+} from "./chunk-NHSLTARU.js";
 import {
   validateLocalSource
-} from "./chunk-VO2I7MTM.js";
-import "./chunk-726GV2NF.js";
-import "./chunk-NECL5IBJ.js";
-import "./chunk-535TM4A5.js";
-import {
-  approveLocalComposition
-} from "./chunk-SVYGXXYR.js";
-import {
-  withLocalOperation
-} from "./chunk-B2V22WRT.js";
-import {
-  installLocalApp
-} from "./chunk-WKTEO6RS.js";
-import "./chunk-GGKFQ3MA.js";
-import "./chunk-DLDFHU7Y.js";
-import "./chunk-7OGTPSKI.js";
-import "./chunk-YLTOLYWM.js";
+} from "./chunk-SBMDONTV.js";
+import "./chunk-NNBJZPFM.js";
+import "./chunk-DZ3VWEV5.js";
+import "./chunk-7NY22B5U.js";
+import "./chunk-DX7PXFCM.js";
+import "./chunk-EFO6AWXN.js";
+import "./chunk-5KAD7W53.js";
+import "./chunk-WL75GQ5M.js";
 import "./chunk-AI2UULNX.js";
-import "./chunk-WDY4IK6Z.js";
+import "./chunk-5J3YUNRY.js";
+import "./chunk-22RSSUNV.js";
 
 // src/lib/compiler/lifecycle/build-operation.ts
 async function runLocalBuild(options) {
@@ -40,10 +40,10 @@ async function runLocalBuild(options) {
         sourceRoot: lifetime.sourceRoot
       });
       return await approveLocalComposition({ options }), options.request.context?.ide && await prepareIdeSupport({
+        frameworkOptions: { ...options, signal: lifetime.signal },
         publishOsDir: lifetime.sourceRoot,
         source,
-        framework,
-        frameworkOptions: { ...options, signal: lifetime.signal }
+        framework
       }), await lifetime.replaceOutput(async (outputDir) => {
         await composeFrameworkSource({
           request: {
@@ -62,7 +62,13 @@ async function runLocalBuild(options) {
           },
           source,
           signal: lifetime.signal,
-          onProgress: (message) => options.onEvent?.({ type: "progress", message })
+          onProgress: (message) => options.onEvent?.({ type: "progress", message }),
+          onWarning: (warning) => options.onEvent?.({
+            type: "diagnostics",
+            diagnostics: {
+              diagnostics: [{ ...warning, severity: "warning" }]
+            }
+          })
         });
         let app = await installLocalApp({
           outputDir,

package/dist/{button-c3WGnxIj.d.ts → button-D6Xp2HBm.d.ts}

@@ -1,11 +1,11 @@
+import { ReactNode, ComponentPropsWithRef } from 'react';
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import { VariantProps } from 'class-variance-authority';
-import { ReactNode, ComponentPropsWithRef } from 'react';
 
 declare const buttonVariants: (props?: ({
-    variant?: "solid" | "soft" | "outline" | "ghost" | null | undefined;
-    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
-    iconOnly?: boolean | null | undefined;
+    readonly variant?: "solid" | "soft" | "outline" | "ghost" | null | undefined;
+    readonly size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    readonly iconOnly?: boolean | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 type ButtonVariantProps = VariantProps<typeof buttonVariants>;
 type ButtonProps = {

package/dist/capture-local-source-WGGDIUU2.js

@@ -0,0 +1,258 @@
+import {
+  assertPublishOsSourceBoundary
+} from "./chunk-7NY22B5U.js";
+import {
+  decodeCssPath,
+  ignoredMediaDocumentWarning,
+  mediaFileByteLimit,
+  readBoundedMediaFile,
+  themeResourceByteLimit
+} from "./chunk-5KAD7W53.js";
+import {
+  isExcludedSourcePath
+} from "./chunk-WL75GQ5M.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/lifecycle/capture-local-source.ts
+import { createHash } from "crypto";
+import { constants } from "fs";
+import {
+  lstat,
+  mkdir,
+  open,
+  readdir,
+  readFile,
+  realpath,
+  writeFile
+} from "fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+import valueParser from "postcss-value-parser";
+function isInside({ root, path }) {
+  let value = relative(root, path);
+  return value !== "" && value !== ".." && !value.startsWith(`..${sep}`) && !isAbsolute(value);
+}
+function cssResourcePaths(css) {
+  let paths = /* @__PURE__ */ new Set();
+  return valueParser(css).walk((node) => {
+    if (node.type !== "function") return;
+    let name = node.value.toLowerCase(), candidates = name === "url" ? node.nodes.filter(
+      (child) => child.type === "string" || child.type === "word"
+    ) : ["image-set", "-webkit-image-set"].includes(name) ? node.nodes.filter((child) => child.type === "string") : [];
+    for (let candidate of candidates) {
+      let decoded = decodeCssPath(candidate.value.trim());
+      if (!decoded || decoded.startsWith("#") || decoded.startsWith("/") || decoded.startsWith("//") || /^[a-z][a-z0-9+.-]*:/iu.test(decoded))
+        continue;
+      let path = decoded.split(/[?#]/u, 1)[0] ?? "";
+      path && paths.add(path);
+    }
+    if (name === "url") return !1;
+  }), [...paths];
+}
+async function collectCssReferencedResources({
+  captureDir,
+  capturedFiles
+}) {
+  let referenced = /* @__PURE__ */ new Set();
+  for (let cssFile of capturedFiles.filter(
+    (path) => path.toLowerCase().endsWith(".css")
+  )) {
+    let css = await readFile(join(captureDir, cssFile), "utf8");
+    for (let urlPath of cssResourcePaths(css)) {
+      let absolutePath = resolve(captureDir, dirname(cssFile), urlPath);
+      isInside({ root: captureDir, path: absolutePath }) && referenced.add(relative(captureDir, absolutePath).split(sep).join("/"));
+    }
+  }
+  return referenced;
+}
+function localFontPaths(config) {
+  if (!config || typeof config != "object" || Array.isArray(config)) return [];
+  let fonts = config.fonts;
+  if (!fonts || typeof fonts != "object" || Array.isArray(fonts)) return [];
+  let paths = /* @__PURE__ */ new Set();
+  for (let role of Object.values(fonts)) {
+    if (!role || typeof role != "object" || Array.isArray(role)) continue;
+    let src = role.src, addPath = (value) => {
+      if (typeof value != "string" || /^[a-z][a-z0-9+.-]*:/iu.test(value) || value.startsWith("//") || value.includes("\0"))
+        return;
+      let normalized = value.replace(/^\/+/, "").replace(/^\.\//, "");
+      normalized && paths.add(normalized);
+    };
+    if (addPath(src), Array.isArray(src))
+      for (let file of src)
+        file && typeof file == "object" && !Array.isArray(file) && addPath(file.path);
+  }
+  return [...paths];
+}
+async function collectConfiguredFontResources({
+  captureDir,
+  capturedFiles
+}) {
+  let referenced = /* @__PURE__ */ new Set();
+  for (let configPath of capturedFiles.filter(
+    (path) => path.endsWith(".config.json")
+  )) {
+    let config;
+    try {
+      config = JSON.parse(await readFile(join(captureDir, configPath), "utf8"));
+    } catch {
+      continue;
+    }
+    for (let fontPath of localFontPaths(config)) {
+      let absolutePath = resolve(captureDir, fontPath);
+      isInside({ root: captureDir, path: absolutePath }) && referenced.add(relative(captureDir, absolutePath).split(sep).join("/"));
+    }
+  }
+  return referenced;
+}
+async function readUnboundedSourceFile({
+  path,
+  entry,
+  signal
+}) {
+  let file = await open(
+    path,
+    constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0)
+  );
+  try {
+    let opened = await file.stat();
+    if (!opened.isFile() || opened.dev !== entry.dev || opened.ino !== entry.ino)
+      throw new AppError({
+        code: "FRAMEWORK_CAPTURE_SOURCE_CHANGED",
+        message: "A source entry changed before capture could read it."
+      });
+    signal?.throwIfAborted();
+    let contents = await file.readFile({ signal });
+    return signal?.throwIfAborted(), contents;
+  } finally {
+    await file.close();
+  }
+}
+async function captureLocalSource({
+  sourceRoot,
+  captureDir,
+  signal
+}) {
+  signal?.throwIfAborted(), await assertPublishOsSourceBoundary(sourceRoot), signal?.throwIfAborted();
+  let root = await realpath(sourceRoot), destination = resolve(captureDir), outputRoot = join(root, ".publish.os");
+  if (!isInside({ root: outputRoot, path: destination }) || await realpath(dirname(destination)) !== dirname(destination))
+    throw new AppError({
+      code: "FRAMEWORK_CAPTURE_OUTPUT_INVALID",
+      message: "Source capture requires an owned path inside source output."
+    });
+  await mkdir(destination).catch((error) => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  let destinationEntry = await lstat(destination);
+  if (!destinationEntry.isDirectory() || destinationEntry.isSymbolicLink() || await realpath(destination) !== destination || (await readdir(destination)).length > 0)
+    throw new AppError({
+      code: "FRAMEWORK_CAPTURE_OUTPUT_INVALID",
+      message: "Source capture requires an empty owned directory."
+    });
+  let capturedFiles = [], deferredResources = [], copyDirectory = async (relativeDirectory) => {
+    signal?.throwIfAborted();
+    let directory = join(root, relativeDirectory), names = (await readdir(directory)).sort();
+    if (!relativeDirectory) {
+      let configIndex = names.indexOf("publish.os.config.json");
+      if (configIndex > 0) {
+        let [configName] = names.splice(configIndex, 1);
+        configName && names.unshift(configName);
+      }
+    }
+    for (let name of names) {
+      signal?.throwIfAborted();
+      let path = relativeDirectory ? `${relativeDirectory}/${name}` : name;
+      if (isExcludedSourcePath(path) || relativeDirectory === "" && name.startsWith(".env"))
+        continue;
+      let sourcePath = join(root, path), outputPath = join(destination, path), entry = await lstat(sourcePath);
+      if (entry.isSymbolicLink())
+        throw new AppError({
+          code: "FRAMEWORK_SOURCE_SYMLINK",
+          message: "Symbolic links are not allowed inside publish.os."
+        });
+      if (!isInside({ root, path: await realpath(sourcePath) }))
+        throw new AppError({
+          code: "FRAMEWORK_SOURCE_PATH_ESCAPE",
+          message: "A source entry resolves outside the selected source."
+        });
+      if (entry.isDirectory()) {
+        await mkdir(outputPath), await copyDirectory(path);
+        continue;
+      }
+      if (!entry.isFile())
+        throw new AppError({
+          code: "FRAMEWORK_SOURCE_ENTRY_NOT_REGULAR",
+          message: "Source capture accepts only directories and regular files."
+        });
+      let contents;
+      if (ignoredMediaDocumentWarning(path))
+        contents = Buffer.alloc(0);
+      else if (path.startsWith("assets/")) {
+        let relativeAssetPath = path.slice(7);
+        contents = await readBoundedMediaFile({
+          path: sourcePath,
+          relativePath: `assets/${relativeAssetPath}`,
+          limit: mediaFileByteLimit(relativeAssetPath),
+          expectedIdentity: { dev: entry.dev, ino: entry.ino },
+          signal
+        });
+      } else if (themeResourceByteLimit(path) !== void 0) {
+        deferredResources.push({
+          path: sourcePath,
+          outputPath,
+          relativePath: path,
+          entry
+        });
+        continue;
+      } else
+        contents = await readUnboundedSourceFile({
+          path: sourcePath,
+          entry,
+          signal
+        });
+      await writeFile(outputPath, contents, { flag: "wx", signal }), capturedFiles.push(path);
+    }
+  };
+  await copyDirectory("");
+  let cssResources = await collectCssReferencedResources({
+    captureDir: destination,
+    capturedFiles
+  });
+  for (let path of await collectConfiguredFontResources({
+    captureDir: destination,
+    capturedFiles
+  }))
+    cssResources.add(path);
+  for (let resource of deferredResources) {
+    signal?.throwIfAborted();
+    let contents = cssResources.has(resource.relativePath) ? await readBoundedMediaFile({
+      path: resource.path,
+      relativePath: resource.relativePath,
+      limit: themeResourceByteLimit(resource.relativePath) ?? 0,
+      expectedIdentity: {
+        dev: resource.entry.dev,
+        ino: resource.entry.ino
+      },
+      signal
+    }) : await readUnboundedSourceFile({
+      path: resource.path,
+      entry: resource.entry,
+      signal
+    });
+    await writeFile(resource.outputPath, contents, { flag: "wx", signal }), capturedFiles.push(resource.relativePath);
+  }
+  let hash = createHash("sha256");
+  for (let path of capturedFiles.sort()) {
+    signal?.throwIfAborted();
+    let contents = await readFile(join(destination, path), { signal });
+    hash.update(JSON.stringify([path, contents.byteLength])), hash.update("\0"), hash.update(contents);
+  }
+  return signal?.throwIfAborted(), {
+    sourceDir: captureDir,
+    sourceRevision: `sha256:${hash.digest("hex")}`
+  };
+}
+export {
+  captureLocalSource
+};

package/dist/chunk-22RSSUNV.js

@@ -0,0 +1,13 @@
+// src/lib/compiler/internal/errors.ts
+var AppError = class extends Error {
+  code;
+  details;
+  fix;
+  constructor({ code, message, details, fix }) {
+    super(message), this.name = "FrameworkError", this.code = code, this.details = details, this.fix = fix;
+  }
+};
+
+export {
+  AppError
+};