@farm.js/core 0.1.51-beta.2 → 0.1.60

package/dist/port-C6GBH4C6.cjs

@@ -0,0 +1,419 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+var _chunkD2X5MUF5cjs = require('./chunk-D2X5MUF5.cjs');
+require('./chunk-BTZ5O6VM.cjs');
+
+// src/mobile/port.ts
+var _fs = require('fs');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var DOM_TAGS = new Set(
+  "div section main article header footer nav aside figure hr p h1 h2 h3 h4 h5 h6 span strong em b i small code label br a button input textarea img ul ol li".split(" ")
+);
+var DOM_PROPS = new Set(
+  "key style href src alt width height value defaultValue placeholder type disabled readOnly autoFocus maxLength rows name id title role htmlFor target rel tabIndex lang dir onClick onChange onInput onFocus onBlur onLoad onError".split(" ")
+);
+var REACT_NAMES = new Set(
+  "default Fragment StrictMode memo forwardRef useState useReducer useMemo useCallback useEffect useRef useId useTransition useDeferredValue startTransition".split(" ")
+);
+var PURE_PACKAGES = /* @__PURE__ */ new Set([
+  "zod",
+  "valibot",
+  "date-fns",
+  "dayjs",
+  "lodash",
+  "lodash-es",
+  "nanoid",
+  "uuid",
+  "clsx",
+  "classnames",
+  "tailwind-merge",
+  "zustand",
+  "jotai",
+  "immer"
+]);
+var CORE_LINK = /* @__PURE__ */ new Set(["@farm.js/core", "@farm.js/core/client"]);
+var SCRIPT = /\.(?:tsx|ts|jsx|js|mjs)$/;
+function packageName(specifier) {
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function posix(file) {
+  return file.split(_path2.default.sep).join("/");
+}
+function withoutExtension(file) {
+  return file.replace(SCRIPT, "");
+}
+function specifierBetween(fromFile, toFile) {
+  const relative = posix(_path2.default.relative(_path2.default.dirname(fromFile), withoutExtension(toFile)));
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function walk(node, visit) {
+  if (Array.isArray(node)) {
+    for (const child of node) walk(child, visit);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  const current = node;
+  if (typeof current.type === "string") visit(current);
+  for (const [key, value] of Object.entries(current)) {
+    if (key !== "type" && key !== "start" && key !== "end" && value && typeof value === "object") {
+      walk(value, visit);
+    }
+  }
+}
+function hasJsx(program) {
+  let found = false;
+  walk(program, (node) => {
+    if (node.type === "JSXElement" || node.type === "JSXFragment") found = true;
+  });
+  return found;
+}
+function staticString(value) {
+  if (!value) return void 0;
+  if ((value.type === "Literal" || value.type === "StringLiteral") && typeof value.value === "string") {
+    return value.value;
+  }
+  if (value.type === "JSXExpressionContainer") return staticString(value.expression);
+  if (value.type === "TemplateLiteral" && value.expressions.length === 0) {
+    return value.quasis.map((quasi) => quasi.value.cooked).join("");
+  }
+  return void 0;
+}
+function lineColumn(source, offset) {
+  const before = source.slice(0, offset).split("\n");
+  return `${before.length}:${before.at(-1).length + 1}`;
+}
+async function emitFarmMobilePort(options) {
+  const { root, graph, portsDir } = options;
+  const read = _nullishCoalesce(options.readFile, () => ( ((file) => _fs.readFileSync.call(void 0, file, "utf8"))));
+  const { parseSync } = await import("rolldown/utils");
+  const problems = [];
+  const copyOf = (file) => _path2.default.join(portsDir, _path2.default.relative(root, file));
+  const parsed = /* @__PURE__ */ new Map();
+  for (const module of graph.modules) {
+    const source = read(module.file);
+    const lang = module.file.endsWith(".tsx") ? "tsx" : module.file.endsWith(".ts") ? "ts" : "jsx";
+    parsed.set(module.file, { source, program: parseSync(module.file, source, { lang }).program });
+  }
+  const copied = new Set(
+    graph.modules.filter((module) => module.file === graph.page || hasJsx(parsed.get(module.file).program)).map((module) => module.file)
+  );
+  const files = {};
+  const tags = /* @__PURE__ */ new Set();
+  const classNames = [];
+  const outputs = [];
+  for (const module of graph.modules) {
+    const label = posix(_path2.default.relative(root, module.file));
+    if (module.serverBoundary) {
+      problems.push(`${label} defines server functions, which ports do not call yet`);
+      continue;
+    }
+    if (!copied.has(module.file)) continue;
+    const { source, program } = parsed.get(module.file);
+    const at = (node) => `${label}:${lineColumn(source, node.start)}`;
+    const edits = [];
+    const resolvedBySource = new Map(module.imports.map((entry2) => [entry2.source, entry2.file]));
+    const linkNames = /* @__PURE__ */ new Set();
+    const reactObjects = /* @__PURE__ */ new Set();
+    let usesDom = false;
+    const rewriteSource = (node, kind) => {
+      const specifier = node.value;
+      const target = resolvedBySource.get(specifier);
+      if (target) {
+        if (kind === "value" && !SCRIPT.test(target)) {
+          problems.push(`${at(node)} imports "${specifier}", an asset ports do not load yet`);
+          return;
+        }
+        const next = specifierBetween(
+          copyOf(module.file),
+          copied.has(target) ? copyOf(target) : target
+        );
+        edits.push({ start: node.start, end: node.end, text: JSON.stringify(next) });
+        return;
+      }
+      if (specifier.startsWith(".") || specifier.startsWith("/")) {
+        if (kind === "value") {
+          problems.push(`${at(node)} imports "${specifier}", an asset ports do not load yet`);
+        }
+        return;
+      }
+      if (kind === "type" || specifier === "react" || PURE_PACKAGES.has(packageName(specifier))) {
+        return;
+      }
+      if (!CORE_LINK.has(specifier)) {
+        problems.push(`${at(node)} imports "${specifier}", which ports do not map yet`);
+      }
+    };
+    for (const statement of program.body) {
+      if (statement.type === "ImportDeclaration") {
+        const typeOnly = statement.importKind === "type";
+        const specifier = statement.source.value;
+        if (!typeOnly && specifier === "react") {
+          for (const imported of statement.specifiers) {
+            if (imported.importKind === "type") continue;
+            if (imported.type !== "ImportSpecifier") reactObjects.add(imported.local.name);
+            const name = imported.type === "ImportSpecifier" ? _nullishCoalesce(imported.imported.name, () => ( imported.imported.value)) : "default";
+            if (!REACT_NAMES.has(name)) {
+              problems.push(
+                `${at(imported)} uses ${name} from "react", which ports do not support yet`
+              );
+            }
+          }
+        }
+        if (/\.css$/i.test(specifier)) {
+          if (statement.specifiers.length > 0) {
+            problems.push(`${at(statement)} imports CSS module names, which ports do not map yet`);
+          } else edits.push({ start: statement.start, end: statement.end, text: "" });
+          continue;
+        }
+        if (!typeOnly && CORE_LINK.has(specifier)) {
+          const values = statement.specifiers.filter(
+            (imported) => imported.importKind !== "type"
+          );
+          for (const imported of values) {
+            const name = imported.type === "ImportSpecifier" ? imported.imported.name : "default";
+            if (name === "Link") linkNames.add(imported.local.name);
+            else
+              problems.push(
+                `${at(imported)} uses ${name} from "${specifier}", which ports do not map yet`
+              );
+          }
+          const types = statement.specifiers.filter(
+            (imported) => imported.importKind === "type"
+          );
+          edits.push({
+            start: statement.start,
+            end: statement.end,
+            text: types.length === 0 ? "" : `import type { ${types.map(
+              (imported) => source.slice(imported.start, imported.end).replace(/^type\s+/, "")
+            ).join(", ")} } from ${JSON.stringify(specifier)};`
+          });
+          continue;
+        }
+        rewriteSource(statement.source, typeOnly ? "type" : "value");
+      } else if ((statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") && statement.source) {
+        rewriteSource(statement.source, statement.exportKind === "type" ? "type" : "value");
+      }
+    }
+    walk(program, (node) => {
+      if (node.type === "MemberExpression" && _optionalChain([node, 'access', _ => _.object, 'optionalAccess', _2 => _2.type]) === "Identifier" && reactObjects.has(node.object.name) && _optionalChain([node, 'access', _3 => _3.property, 'optionalAccess', _4 => _4.type]) === "Identifier" && !REACT_NAMES.has(node.property.name)) {
+        problems.push(
+          `${at(node)} uses ${node.property.name} from "react", which ports do not support yet`
+        );
+      }
+      if (node.type === "ImportExpression") {
+        problems.push(`${at(node)} imports a module at runtime, which ports do not follow yet`);
+      }
+      if (node.type === "JSXOpeningElement" || node.type === "JSXClosingElement") {
+        const name = node.name;
+        if (name.type !== "JSXIdentifier") return;
+        const className = (tag) => {
+          if (node.type !== "JSXOpeningElement") return;
+          for (const attribute of node.attributes) {
+            if (attribute.type !== "JSXAttribute" || attribute.name.name !== "className") continue;
+            const classes = staticString(attribute.value);
+            if (classes === void 0) {
+              problems.push(`${at(attribute)} <${tag}> builds its class names at runtime`);
+              continue;
+            }
+            classNames.push({
+              edits,
+              attribute,
+              tag,
+              classes: classes.split(/\s+/).filter(Boolean),
+              at: at(attribute)
+            });
+          }
+        };
+        if (linkNames.has(name.name)) {
+          edits.push({ start: name.start, end: name.end, text: "__FarmLink" });
+          tags.add("a");
+          className("a");
+          return;
+        }
+        if (!/^[a-z]/.test(name.name)) return;
+        if (!DOM_TAGS.has(name.name)) {
+          if (node.type === "JSXOpeningElement") {
+            problems.push(`${at(node)} renders <${name.name}>, which ports do not draw yet`);
+          }
+          return;
+        }
+        usesDom = true;
+        tags.add(name.name);
+        edits.push({ start: name.start, end: name.end, text: `__FarmDom.${name.name}` });
+        if (node.type !== "JSXOpeningElement") return;
+        for (const attribute of node.attributes) {
+          if (attribute.type === "JSXSpreadAttribute") {
+            problems.push(`${at(attribute)} spreads props on <${name.name}>`);
+            continue;
+          }
+          const prop = attribute.name.type === "JSXNamespacedName" ? `${attribute.name.namespace.name}:${attribute.name.name.name}` : attribute.name.name;
+          if (prop !== "className" && !DOM_PROPS.has(prop) && !/^(?:aria|data)-/.test(prop)) {
+            problems.push(`${at(attribute)} <${name.name} ${prop}> has no port mapping yet`);
+          }
+        }
+        className(name.name);
+      }
+    });
+    if (linkNames.size > 0 || usesDom) {
+      const names = [
+        ...usesDom ? ["FarmDom as __FarmDom"] : [],
+        ...linkNames.size > 0 ? ["Link as __FarmLink"] : []
+      ];
+      const body = program.body;
+      const first = body.find(
+        (statement) => !(statement.type === "ExpressionStatement" && statement.directive)
+      );
+      edits.push({
+        start: _nullishCoalesce(_optionalChain([first, 'optionalAccess', _5 => _5.start]), () => ( source.length)),
+        end: _nullishCoalesce(_optionalChain([first, 'optionalAccess', _6 => _6.start]), () => ( source.length)),
+        text: `import { ${names.join(", ")} } from "@farm.js/native/elements";
+`
+      });
+    }
+    outputs.push({
+      key: posix(_path2.default.relative(portsDir, copyOf(module.file))),
+      label,
+      source,
+      edits
+    });
+  }
+  const page = parsed.get(graph.page);
+  const hasDefault = page.program.body.some(
+    (statement) => statement.type === "ExportDefaultDeclaration"
+  );
+  if (!hasDefault) problems.push(`${posix(_path2.default.relative(root, graph.page))} has no default export`);
+  const sheets = [];
+  const themeDeclarations = [];
+  let tailwind = false;
+  for (const file of _nullishCoalesce(options.stylesheets, () => ( []))) {
+    let css = read(file).replace(/\/\*[\s\S]*?\*\//g, "");
+    css = css.replace(/@import\s+(["'])tailwindcss\1[^;]*;/g, () => {
+      tailwind = true;
+      return "";
+    });
+    css = css.replace(/@source\b[^;]*;/g, "");
+    css = css.replace(/@theme\b[^{;]*\{([^{}]*)\}/g, (_block, body) => {
+      for (const match of body.matchAll(/(--[\w*-]+)\s*:\s*([^;]+);?/g)) {
+        themeDeclarations.push([match[1], match[2].trim()]);
+      }
+      return "";
+    });
+    const directive = /@(?:import|layer|tailwind|apply|theme|utility|plugin|config|custom-variant|variant|reference)\b/.exec(
+      css
+    );
+    if (directive) {
+      problems.push(
+        `${posix(_path2.default.relative(root, file))} uses ${directive[0]}, which ports do not read yet`
+      );
+    } else sheets.push(_chunkD2X5MUF5cjs.parseFarmNativeStylesheet.call(void 0, css));
+  }
+  for (const specifier of _nullishCoalesce(options.unreadStylesheets, () => ( []))) {
+    problems.push(`the app imports "${specifier}", which ports cannot read as plain CSS`);
+  }
+  const sheet = {};
+  const rootVars = {
+    light: Object.assign(
+      {},
+      ...sheets.map((sheet2) => sheet2.vars.light),
+      Object.fromEntries(themeDeclarations)
+    ),
+    dark: Object.assign({}, ...sheets.map((sheet2) => sheet2.vars.dark))
+  };
+  const theme = themeDeclarations.length > 0 ? _chunkD2X5MUF5cjs.createFarmNativeTheme.call(void 0, themeDeclarations, rootVars) : void 0;
+  const contextClasses = /* @__PURE__ */ new Set([
+    ...graph.layoutClasses,
+    ...classNames.flatMap((entry2) => entry2.classes)
+  ]);
+  for (const { edits, attribute, tag, classes, at } of classNames) {
+    const utilities = [];
+    const appClasses = [];
+    for (const token of classes) {
+      const inTable = _chunkD2X5MUF5cjs.resolveFarmNativeClasses.call(void 0, token, theme).unsupported.length === 0;
+      const styled = _chunkD2X5MUF5cjs.inspectFarmNativeStylesheets.call(void 0, sheets, { class: token }).styled;
+      if (tailwind && inTable) utilities.push(token);
+      if (styled) appClasses.push(token);
+      else if (tailwind && !inTable) {
+        problems.push(
+          `${at} ${_nullishCoalesce(_chunkD2X5MUF5cjs.farmNativeClassProblem.call(void 0, token, theme), () => ( `class "${token}" has no port style`))}`
+        );
+      }
+    }
+    const tw = _chunkD2X5MUF5cjs.resolveFarmNativeClasses.call(void 0, utilities.join(" "), theme);
+    const css = _chunkD2X5MUF5cjs.cascadeFarmNativeStylesheetsForElement.call(void 0, 
+      sheets,
+      { tag, classes: appClasses },
+      contextClasses
+    );
+    problems.push(...css.problems.map((message) => `${at} ${message}`));
+    const resolved = {
+      ...utilities.length > 0 ? { tw: { style: tw.style, ...tw.dark ? { dark: tw.dark } : {} } } : {},
+      css: {
+        style: css.style,
+        ...Object.keys(css.dark).length > 0 ? { dark: css.dark } : {},
+        ...css.inherit.length > 0 ? { inherit: css.inherit } : {}
+      }
+    };
+    edits.push({
+      start: attribute.start,
+      end: attribute.end,
+      text: `__farm={${JSON.stringify(resolved)}}`
+    });
+  }
+  for (const { key, label, source, edits } of outputs) {
+    let output = source;
+    for (const edit of edits.sort(
+      (left, right) => right.start - left.start || right.end - left.end
+    )) {
+      output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+    }
+    files[key] = `// Generated by Farm from ${label} for its React Native port. Do not edit.
+${output}`;
+  }
+  for (const tag of ["html", "body", ...[...tags].sort()]) {
+    const cascaded = _chunkD2X5MUF5cjs.cascadeFarmNativeStylesheetsForElement.call(void 0, sheets, { tag }, contextClasses);
+    problems.push(...cascaded.problems);
+    const entry2 = {
+      ...Object.keys(cascaded.style).length > 0 ? { style: cascaded.style } : {},
+      ...Object.keys(cascaded.dark).length > 0 ? { dark: cascaded.dark } : {},
+      ...cascaded.inherit.length > 0 ? { inherit: cascaded.inherit } : {}
+    };
+    if (Object.keys(entry2).length > 0) sheet[tag] = entry2;
+  }
+  if (problems.length > 0) return { problems: [...new Set(problems)] };
+  const hasMetadata = page.program.body.some(
+    (statement) => statement.type === "ExportNamedDeclaration" && _optionalChain([statement, 'access', _7 => _7.declaration, 'optionalAccess', _8 => _8.declarations, 'optionalAccess', _9 => _9.some, 'call', _10 => _10(
+      (declaration) => _optionalChain([declaration, 'access', _11 => _11.id, 'optionalAccess', _12 => _12.name]) === "metadata"
+    )])
+  );
+  const entry = `${options.module}.port.tsx`;
+  const pageImport = specifierBetween(_path2.default.join(portsDir, entry), copyOf(graph.page));
+  files[entry] = [
+    `// Generated by Farm: the React Native port of ${posix(_path2.default.relative(root, graph.page))}. Do not edit.`,
+    'import { useRouteParams } from "@farm.js/native";',
+    'import { FarmDomScreen } from "@farm.js/native/elements";',
+    `import Page from ${JSON.stringify(pageImport)};`,
+    ...hasMetadata ? [`export { metadata } from ${JSON.stringify(pageImport)};`] : [],
+    "",
+    "// The app's CSS for each element the page renders, light and dark.",
+    `const sheet = ${JSON.stringify(sheet)};`,
+    "",
+    "export default function FarmPort() {",
+    "  return (",
+    `    <FarmDomScreen sheet={sheet}${tailwind ? " preflight" : ""}>`,
+    "      <Page params={useRouteParams()} />",
+    "    </FarmDomScreen>",
+    "  );",
+    "}",
+    ""
+  ].join("\n");
+  return { port: { entry, files } };
+}
+
+
+exports.emitFarmMobilePort = emitFarmMobilePort;