@farm.js/plugin 0.1.0-beta.1 → 0.1.0-beta.100

package/dist/rsc/nitro-build.js

@@ -219,9 +219,20 @@ function createRscRequest(event) {
   return new Request(event.req, { signal: controller.signal });
 }
 
-export default defineEventHandler((event) => handler(createRscRequest(event), {
-  waitUntil: (promise) => event.waitUntil(promise),
-}));
+export default defineEventHandler(async (event) => {
+  const response = await handler(createRscRequest(event), {
+    waitUntil: (promise) => event.waitUntil(promise),
+  });
+  // H3's prepared headers override Response headers. Keep both the runtime's
+  // fields (e.g. Accept-Encoding from static middleware) and the app's fields.
+  const vary = [event.res.headers.get('vary'), response.headers.get('vary')]
+    .filter(Boolean).join(',').split(',').map(value => value.trim()).filter(Boolean);
+  if (vary.length) {
+    const fields = new Map(vary.map(value => [value.toLowerCase(), value]));
+    event.res.headers.set('vary', fields.has('*') ? '*' : [...fields.values()].join(', '));
+  }
+  return response;
+});
 `.trim();
     const entryPath = path.join(buildDir, "rsc-entry.mjs");
     mkdirSync(buildDir, { recursive: true });
@@ -271,7 +282,15 @@ export async function buildRscNitro(options) {
         },
         // Externalize rsc/ssr so we don't bundle (they reference Vite-generated manifest). We copy dist into server output after build.
         rollupConfig: {
-            external: (id) => id.includes("../dist/") || id.includes("dist/rsc") || id.includes("dist/ssr"),
+            external: (id) => {
+                // Ids reach this predicate in both separator forms on Windows, and matching
+                // only the POSIX one makes the same module external in one pass and not in
+                // the next, which Rollup rejects.
+                const normalized = id.split("\\").join("/");
+                return (normalized.includes("../dist/") ||
+                    normalized.includes("dist/rsc") ||
+                    normalized.includes("dist/ssr"));
+            },
         },
         compatibilityDate: "2024-12-01",
         minify: true,
@@ -366,13 +385,14 @@ export async function buildRscNitro(options) {
         }
     }
     if (existsSync(ssrIndexPath)) {
-        const assetsDir = path.join(publicDir, "assets");
+        const assetsDirName = assetsDir ?? "assets";
+        const assetsRoot = path.join(publicDir, assetsDirName);
         let clientCssHref = "";
-        if (existsSync(assetsDir)) {
-            const files = readdirSync(assetsDir);
+        if (existsSync(assetsRoot)) {
+            const files = readdirSync(assetsRoot);
             const cssFile = files.find((f) => f.endsWith(".css"));
             if (cssFile)
-                clientCssHref = "/assets/" + cssFile;
+                clientCssHref = `/${assetsDirName}/${cssFile}`;
         }
         try {
             let ssrCode = readFileSync(ssrIndexPath, "utf-8");

package/dist/rsc/optimized-boundary.d.ts

@@ -1,5 +1,6 @@
 import { type RenderOptions, type StrataDocument } from "@farming-labs/strata";
 import { type StaticFragmentBoundary, type StaticFragmentProps } from "@farming-labs/strata/react-server";
+import { type ReactElement } from "react";
 export type { RenderOptions, StrataDocument, StrataElement, StrataNode, StrataTag, StrataText, } from "@farming-labs/strata";
 export interface OptimizedBoundaryProps extends Omit<StaticFragmentProps, "content"> {
     /**
@@ -9,12 +10,20 @@ export interface OptimizedBoundaryProps extends Omit<StaticFragmentProps, "conte
     document: StrataDocument;
     renderOptions?: RenderOptions;
 }
+/**
+ * Internal compiler target for automatic optimized boundaries. This helper is
+ * deliberately fail-open: any unsupported or unsafe tree returns the original
+ * React element unchanged.
+ *
+ * @internal
+ */
+export declare function _optimizeBoundary(element: ReactElement): ReactElement;
 /**
  * Render a typed host-only document with the optimized native runtime and
  * place it inside an opaque React-owned boundary.
  *
  * Enable `experimental.optimizedBoundary` before importing this component.
  */
-export declare function OptimizedBoundary({ document, renderOptions, ...props }: OptimizedBoundaryProps): import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+export declare function OptimizedBoundary({ document, renderOptions, ...props }: OptimizedBoundaryProps): ReactElement;
 export type OptimizedBoundaryTag = StaticFragmentBoundary;
 //# sourceMappingURL=optimized-boundary.d.ts.map

package/dist/rsc/optimized-boundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"optimized-boundary.d.ts","sourceRoot":"","sources":["../../src/rsc/optimized-boundary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACvF,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACzB,MAAM,mCAAmC,CAAC;AAE3C,YAAY,EACV,aAAa,EACb,cAAc,EACd,aAAa,EACb,UAAU,EACV,SAAS,EACT,UAAU,GACX,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,sBAAuB,SAAQ,IAAI,CAAC,mBAAmB,EAAE,SAAS,CAAC;IAClF;;;OAGG;IACH,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,GAAG,KAAK,EAAE,EAAE,sBAAsB,0FAM9F;AAED,MAAM,MAAM,oBAAoB,GAAG,sBAAsB,CAAC"}
+{"version":3,"file":"optimized-boundary.d.ts","sourceRoot":"","sources":["../../src/rsc/optimized-boundary.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,cAAc,EAIpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACzB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAA2C,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAEnF,YAAY,EACV,aAAa,EACb,cAAc,EACd,aAAa,EACb,UAAU,EACV,SAAS,EACT,UAAU,GACX,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,sBAAuB,SAAQ,IAAI,CAAC,mBAAmB,EAAE,SAAS,CAAC;IAClF;;;OAGG;IACH,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAiND;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,YAAY,CAsBrE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,aAAa,EACb,GAAG,KAAK,EACT,EAAE,sBAAsB,GAAG,YAAY,CAMvC;AAED,MAAM,MAAM,oBAAoB,GAAG,sBAAsB,CAAC"}

package/dist/rsc/optimized-boundary.js

@@ -1,5 +1,233 @@
-import { render } from "@farming-labs/strata";
+import { render, } from "@farming-labs/strata";
 import { StaticFragment, } from "@farming-labs/strata/react-server";
+import { createElement, Fragment, isValidElement } from "react";
+const AUTOMATIC_MIN_NODES = 8;
+const AUTOMATIC_MIN_BYTES = 256;
+const AUTOMATIC_BOUNDARIES = new Set([
+    "article",
+    "aside",
+    "div",
+    "footer",
+    "header",
+    "main",
+    "nav",
+    "section",
+    "span",
+]);
+const STRATA_TAGS = new Set([
+    "a",
+    "abbr",
+    "address",
+    "article",
+    "aside",
+    "b",
+    "blockquote",
+    "br",
+    "caption",
+    "cite",
+    "code",
+    "col",
+    "colgroup",
+    "dd",
+    "del",
+    "details",
+    "dfn",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "figcaption",
+    "figure",
+    "footer",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "hr",
+    "i",
+    "img",
+    "ins",
+    "kbd",
+    "li",
+    "main",
+    "mark",
+    "nav",
+    "ol",
+    "p",
+    "pre",
+    "q",
+    "s",
+    "samp",
+    "section",
+    "small",
+    "span",
+    "strong",
+    "sub",
+    "summary",
+    "sup",
+    "table",
+    "tbody",
+    "td",
+    "tfoot",
+    "th",
+    "thead",
+    "time",
+    "tr",
+    "u",
+    "ul",
+    "var",
+    "wbr",
+]);
+const BOOLEAN_ATTRIBUTES = new Set(["hidden", "reversed"]);
+const ATTRIBUTE_NAMES = {
+    className: "class",
+    colSpan: "colspan",
+    dateTime: "datetime",
+    rowSpan: "rowspan",
+};
+function AutomaticOptimizedBoundary({ document, fallback, ...props }) {
+    let content;
+    try {
+        content = render(document);
+    }
+    catch {
+        return fallback;
+    }
+    if (content.nodeCount < AUTOMATIC_MIN_NODES && content.bytes < AUTOMATIC_MIN_BYTES) {
+        return fallback;
+    }
+    return StaticFragment({ ...props, content });
+}
+function attributeValue(name, value) {
+    if (value === null || value === undefined)
+        return undefined;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+        return String(value);
+    }
+    if (typeof value !== "boolean")
+        return null;
+    if (name.startsWith("aria-") || name.startsWith("data-"))
+        return String(value);
+    if (BOOLEAN_ATTRIBUTES.has(name))
+        return value ? "" : undefined;
+    return null;
+}
+function convertAttributes(tag, props) {
+    const attributes = {};
+    for (const [reactName, rawValue] of Object.entries(props)) {
+        if (reactName === "children")
+            continue;
+        if (reactName === "dangerouslySetInnerHTML" ||
+            reactName === "ref" ||
+            reactName === "style" ||
+            reactName === "suppressHydrationWarning" ||
+            /^on[A-Z]/.test(reactName)) {
+            return null;
+        }
+        const name = ATTRIBUTE_NAMES[reactName] || reactName;
+        const value = attributeValue(name, rawValue);
+        if (value === null)
+            return null;
+        if (value !== undefined)
+            attributes[name] = value;
+    }
+    return Object.keys(attributes).length > 0 ? attributes : {};
+}
+function automaticDocumentFromElement(element) {
+    const rootProps = element.props;
+    const children = [];
+    if (!appendStrataNodes(rootProps.children, children))
+        return null;
+    return { type: "document", ...(children.length > 0 ? { children } : {}) };
+}
+function appendStrataNodes(value, output) {
+    if (value === null || value === undefined || typeof value === "boolean")
+        return true;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+        output.push({ type: "text", value: String(value) });
+        return true;
+    }
+    if (Array.isArray(value)) {
+        for (const child of value) {
+            if (!appendStrataNodes(child, output))
+                return false;
+        }
+        return true;
+    }
+    if (!isValidElement(value))
+        return false;
+    const element = value;
+    const props = element.props;
+    if (element.type === Fragment)
+        return appendStrataNodes(props.children, output);
+    if (element.type === OptimizedBoundary || element.type === AutomaticOptimizedBoundary) {
+        const boundary = props.as ?? "div";
+        if (typeof boundary !== "string" || !STRATA_TAGS.has(boundary))
+            return false;
+        const { as: _as, document: _document, fallback: _fallback, ...boundaryProps } = props;
+        const attributes = convertAttributes(boundary, boundaryProps);
+        if (!attributes)
+            return false;
+        const document = props.document;
+        if (!document || document.type !== "document")
+            return false;
+        output.push({
+            type: "element",
+            tag: boundary,
+            ...(Object.keys(attributes).length > 0 ? { attributes } : {}),
+            ...(document.children?.length ? { children: document.children } : {}),
+        });
+        return true;
+    }
+    if (typeof element.type !== "string" || !STRATA_TAGS.has(element.type)) {
+        return false;
+    }
+    const tag = element.type;
+    const attributes = convertAttributes(tag, props);
+    if (!attributes)
+        return false;
+    const children = [];
+    if (!appendStrataNodes(props.children, children))
+        return false;
+    output.push({
+        type: "element",
+        tag,
+        ...(Object.keys(attributes).length > 0 ? { attributes } : {}),
+        ...(children.length > 0 ? { children } : {}),
+    });
+    return true;
+}
+/**
+ * Internal compiler target for automatic optimized boundaries. This helper is
+ * deliberately fail-open: any unsupported or unsafe tree returns the original
+ * React element unchanged.
+ *
+ * @internal
+ */
+export function _optimizeBoundary(element) {
+    if (!isValidElement(element) ||
+        typeof element.type !== "string" ||
+        !AUTOMATIC_BOUNDARIES.has(element.type)) {
+        return element;
+    }
+    const props = element.props;
+    if (props.dangerouslySetInnerHTML !== undefined || props.ref !== undefined)
+        return element;
+    const document = automaticDocumentFromElement(element);
+    if (!document)
+        return element;
+    const { children: _children, ...boundaryProps } = props;
+    return createElement(AutomaticOptimizedBoundary, {
+        ...boundaryProps,
+        ...(element.key !== null ? { key: element.key } : {}),
+        as: element.type,
+        document,
+        fallback: element,
+    });
+}
 /**
  * Render a typed host-only document with the optimized native runtime and
  * place it inside an opaque React-owned boundary.

package/dist/rsc/route-action-transform.d.ts

@@ -0,0 +1,11 @@
+export type FarmRouteActionClientTransformResult = {
+    code: string;
+    routes: string[];
+};
+/**
+ * Replace a programmatic route imported by the browser with a small action-only
+ * proxy. Route loaders, components, database imports, and other server code do
+ * not enter the client graph.
+ */
+export declare function transformFarmRouteActionClients(code: string, id: string): FarmRouteActionClientTransformResult | null;
+//# sourceMappingURL=route-action-transform.d.ts.map

package/dist/rsc/route-action-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-action-transform.d.ts","sourceRoot":"","sources":["../../src/rsc/route-action-transform.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,oCAAoC,GAAG;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAcF;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,oCAAoC,GAAG,IAAI,CAqC7C"}