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

package/dist/rsc/optimized-boundary.js

@@ -0,0 +1,243 @@
+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.
+ *
+ * Enable `experimental.optimizedBoundary` before importing this component.
+ */
+export function OptimizedBoundary({ document, renderOptions, ...props }) {
+    const content = render(document, renderOptions);
+    return StaticFragment({
+        ...props,
+        content,
+    });
+}

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"}

package/dist/rsc/route-action-transform.js

@@ -0,0 +1,369 @@
+const ROUTE_FACTORY_IMPORT_RE = /\bimport\s+(?:type\s+)?(?:[A-Za-z_$][\w$]*\s*,\s*)?(\{[^}]*\})\s+from\s*["']@farm.js\/core(?:\/routes)?["']\s*;?/g;
+const EXPORTED_ROUTE_RE = /\bexport\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*([A-Za-z_$][\w$]*)\s*\(/g;
+const IMPORT_RE = /\bimport\s+(?!type\b)([\s\S]*?)\s+from\s*(["'][^"']+["'])\s*;?/g;
+const IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/;
+const MODULE_EXT_RE = /\.[cm]?[jt]sx?$/;
+/**
+ * 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 function transformFarmRouteActionClients(code, id) {
+    if (!isTransformableModule(id) || !code.includes("createRoute") || !code.includes("actions")) {
+        return null;
+    }
+    const routeFactories = findRouteFactoryImportNames(code);
+    if (routeFactories.size === 0)
+        return null;
+    const routes = findActionRoutes(code, routeFactories, id);
+    if (routes.length === 0)
+        return null;
+    const importStatements = findRuntimeImports(code);
+    const requiredImports = new Set();
+    for (const route of routes) {
+        for (const action of route.actions) {
+            const statement = importStatements.get(action.local);
+            if (!statement) {
+                throw new Error(`[Farm.js] Route "${route.exportName}" action "${action.name}" in ${id} must reference ` +
+                    "a server function imported from another module. Define and export createServerFn in an actions module, then import it into the route.");
+            }
+            requiredImports.add(statement);
+        }
+    }
+    const output = [
+        ...requiredImports,
+        ...routes.map((route) => generateRouteActionProxy(route)),
+        ...findRouteDefaultExports(code, routes),
+    ].join("\n");
+    return {
+        code: `${output}\n`,
+        routes: routes.map((route) => route.exportName),
+    };
+}
+function findRouteFactoryImportNames(code) {
+    const names = new Set();
+    for (const match of code.matchAll(ROUTE_FACTORY_IMPORT_RE)) {
+        const namedImports = (match[1] ?? "").slice(1, -1).split(",");
+        for (const specifier of namedImports) {
+            const normalized = specifier.trim().replace(/^type\s+/, "");
+            const specifierMatch = normalized.match(/^createRoute(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+            if (specifierMatch)
+                names.add(specifierMatch[1] ?? "createRoute");
+        }
+    }
+    return names;
+}
+function findActionRoutes(code, factories, id) {
+    const routes = [];
+    for (const match of code.matchAll(EXPORTED_ROUTE_RE)) {
+        const exportName = match[1];
+        const calleeName = match[2];
+        if (!exportName || !calleeName || !factories.has(calleeName))
+            continue;
+        const openParen = (match.index ?? 0) + match[0].length - 1;
+        const closeParen = findMatchingDelimiter(code, openParen, "(", ")");
+        if (closeParen === -1)
+            continue;
+        const args = splitTopLevel(code, openParen + 1, closeParen);
+        if (args.length < 2)
+            continue;
+        const pathSource = readSegment(code, args[0]);
+        if (!isQuotedString(pathSource)) {
+            throw new Error(`[Farm.js] Route "${exportName}" in ${id} must use a static string path before its actions can be imported by a Client Component.`);
+        }
+        const options = readSegment(code, args[1]);
+        if (!options.startsWith("{") || !options.endsWith("}"))
+            continue;
+        const properties = parseObjectProperties(options.slice(1, -1));
+        const actionsSource = properties.get("actions");
+        if (!actionsSource)
+            continue;
+        if (!actionsSource.startsWith("{") || !actionsSource.endsWith("}")) {
+            throw new Error(`[Farm.js] Route "${exportName}" actions in ${id} must be an object literal so Farm can generate its client proxy.`);
+        }
+        const actions = parseActionProperties(actionsSource.slice(1, -1), exportName, id);
+        if (actions.length === 0)
+            continue;
+        const defaultSource = properties.get("defaultAction");
+        const defaultAction = defaultSource
+            ? parseStringValue(defaultSource, exportName, id)
+            : actions[0].name;
+        if (!actions.some((action) => action.name === defaultAction)) {
+            throw new Error(`[Farm.js] Route "${exportName}" defaultAction "${defaultAction}" in ${id} does not match a declared action.`);
+        }
+        routes.push({ exportName, pathSource, actions, defaultAction });
+    }
+    return routes;
+}
+function parseActionProperties(source, routeName, id) {
+    const properties = parseObjectProperties(source, true);
+    const actions = [];
+    for (const [name, value] of properties) {
+        const local = value || name;
+        if (!IDENTIFIER_RE.test(name) || !IDENTIFIER_RE.test(local)) {
+            throw new Error(`[Farm.js] Route "${routeName}" actions in ${id} must use identifier entries such as { update } or { update: updateProduct }.`);
+        }
+        actions.push({ name, local });
+    }
+    return actions;
+}
+function parseObjectProperties(source, allowShorthand = false) {
+    const properties = new Map();
+    for (const segment of splitTopLevel(source, 0, source.length)) {
+        const entry = readSegment(source, segment);
+        if (!entry)
+            continue;
+        if (entry.startsWith("...")) {
+            properties.set(entry, "");
+            continue;
+        }
+        const colon = findTopLevelColon(entry);
+        if (colon === -1) {
+            if (allowShorthand)
+                properties.set(entry, "");
+            continue;
+        }
+        const keySource = entry.slice(0, colon).trim();
+        const value = entry.slice(colon + 1).trim();
+        const key = isQuotedString(keySource) ? unquote(keySource) : keySource;
+        properties.set(key, value);
+    }
+    return properties;
+}
+function findRuntimeImports(code) {
+    const imports = new Map();
+    for (const match of code.matchAll(IMPORT_RE)) {
+        const clause = (match[1] ?? "").trim();
+        const statement = match[0];
+        const namedStart = clause.indexOf("{");
+        const namedEnd = clause.lastIndexOf("}");
+        if (namedStart > -1 && namedEnd > namedStart) {
+            for (const specifier of clause.slice(namedStart + 1, namedEnd).split(",")) {
+                const normalized = specifier.trim().replace(/^type\s+/, "");
+                if (!normalized || specifier.trim().startsWith("type "))
+                    continue;
+                const parts = normalized.split(/\s+as\s+/);
+                const local = parts[1] ?? parts[0];
+                if (local && IDENTIFIER_RE.test(local))
+                    imports.set(local, statement);
+            }
+        }
+        const defaultImport = clause
+            .slice(0, namedStart === -1 ? clause.length : namedStart)
+            .replace(/,$/, "")
+            .trim();
+        if (IDENTIFIER_RE.test(defaultImport))
+            imports.set(defaultImport, statement);
+    }
+    return imports;
+}
+function generateRouteActionProxy(route) {
+    const actions = route.actions
+        .map((action) => `${JSON.stringify(action.name)}: ${action.local}`)
+        .join(", ");
+    const defaultAction = route.actions.find((action) => action.name === route.defaultAction);
+    return `export const ${route.exportName} = Object.freeze({
+  __farmRouteActionTarget: true,
+  path: ${route.pathSource},
+  actions: Object.freeze({ ${actions} }),
+  defaultAction: ${JSON.stringify(route.defaultAction)},
+  action: ${defaultAction.local},
+});`;
+}
+function findRouteDefaultExports(code, routes) {
+    const exports = [];
+    for (const route of routes) {
+        const defaultExport = new RegExp(`\\bexport\\s+default\\s+${escapeRegExp(route.exportName)}\\s*;?`);
+        if (defaultExport.test(code))
+            exports.push(`export default ${route.exportName};`);
+    }
+    return exports;
+}
+function splitTopLevel(source, start, end) {
+    const segments = [];
+    let segmentStart = start;
+    let parens = 0;
+    let braces = 0;
+    let brackets = 0;
+    let quote = null;
+    let escaped = false;
+    let lineComment = false;
+    let blockComment = false;
+    for (let index = start; index < end; index++) {
+        const char = source[index];
+        const next = source[index + 1];
+        if (lineComment) {
+            if (char === "\n" || char === "\r")
+                lineComment = false;
+            continue;
+        }
+        if (blockComment) {
+            if (char === "*" && next === "/") {
+                blockComment = false;
+                index++;
+            }
+            continue;
+        }
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (char === "\\")
+                escaped = true;
+            else if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            lineComment = true;
+            index++;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            blockComment = true;
+            index++;
+            continue;
+        }
+        if (char === "'" || char === '"' || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (char === "(")
+            parens++;
+        else if (char === ")")
+            parens--;
+        else if (char === "{")
+            braces++;
+        else if (char === "}")
+            braces--;
+        else if (char === "[")
+            brackets++;
+        else if (char === "]")
+            brackets--;
+        else if (char === "," && parens === 0 && braces === 0 && brackets === 0) {
+            segments.push([segmentStart, index]);
+            segmentStart = index + 1;
+        }
+    }
+    segments.push([segmentStart, end]);
+    return segments;
+}
+function findTopLevelColon(source) {
+    const segments = splitTopLevel(source, 0, source.length);
+    if (segments.length !== 1)
+        return -1;
+    let parens = 0;
+    let braces = 0;
+    let brackets = 0;
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < source.length; index++) {
+        const char = source[index];
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (char === "\\")
+                escaped = true;
+            else if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === "'" || char === '"' || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (char === "(")
+            parens++;
+        else if (char === ")")
+            parens--;
+        else if (char === "{")
+            braces++;
+        else if (char === "}")
+            braces--;
+        else if (char === "[")
+            brackets++;
+        else if (char === "]")
+            brackets--;
+        else if (char === ":" && parens === 0 && braces === 0 && brackets === 0)
+            return index;
+    }
+    return -1;
+}
+function findMatchingDelimiter(source, openIndex, open, close) {
+    let depth = 0;
+    let quote = null;
+    let lineComment = false;
+    let blockComment = false;
+    let escaped = false;
+    for (let index = openIndex; index < source.length; index++) {
+        const char = source[index];
+        const next = source[index + 1];
+        if (lineComment) {
+            if (char === "\n" || char === "\r")
+                lineComment = false;
+            continue;
+        }
+        if (blockComment) {
+            if (char === "*" && next === "/") {
+                blockComment = false;
+                index++;
+            }
+            continue;
+        }
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (char === "\\")
+                escaped = true;
+            else if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            lineComment = true;
+            index++;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            blockComment = true;
+            index++;
+            continue;
+        }
+        if (char === "'" || char === '"' || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (char === open)
+            depth++;
+        else if (char === close && --depth === 0)
+            return index;
+    }
+    return -1;
+}
+function readSegment(source, segment) {
+    return source.slice(segment[0], segment[1]).trim();
+}
+function parseStringValue(source, routeName, id) {
+    if (!isQuotedString(source)) {
+        throw new Error(`[Farm.js] Route "${routeName}" defaultAction in ${id} must be a static string.`);
+    }
+    return unquote(source);
+}
+function isQuotedString(value) {
+    return (value.length >= 2 &&
+        ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))));
+}
+function unquote(value) {
+    const quote = value[0];
+    const body = value.slice(1, -1);
+    if (quote === '"')
+        return JSON.parse(value);
+    return body.replace(/\\'/g, "'").replace(/\\\\/g, "\\");
+}
+function isTransformableModule(id) {
+    const cleanId = id.split("?", 1)[0];
+    return MODULE_EXT_RE.test(cleanId) && !/\.d\.[cm]?ts$/.test(cleanId);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/rsc/server-fn-transform.d.ts

@@ -0,0 +1,6 @@
+export type FarmServerFnTransformResult = {
+    code: string;
+    exports: string[];
+};
+export declare function transformFarmServerFns(code: string, id: string): FarmServerFnTransformResult | null;
+//# sourceMappingURL=server-fn-transform.d.ts.map

package/dist/rsc/server-fn-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-fn-transform.d.ts","sourceRoot":"","sources":["../../src/rsc/server-fn-transform.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,2BAA2B,GAAG;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,2BAA2B,GAAG,IAAI,CAiCpC"}