rescript-relay 0.0.0-autocodesplit-09ee6f6c

package/compiler.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+"use strict";
+
+var spawn = require("child_process").spawn;
+var path = require("path");
+
+var input = process.argv.slice(2);
+
+spawn(path.join(__dirname, "rescript-relay-compiler.exe"), input, {
+  stdio: "inherit",
+}).on("exit", process.exit);

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "rescript-relay",
+  "version": "0.0.0-autocodesplit-09ee6f6c",
+  "main": "src/RescriptRelay.res",
+  "license": "MIT",
+  "author": "Gabriel Nordeborn",
+  "sideEffects": false,
+  "repository": "https://github.com/zth/rescript-relay",
+  "description": "Use Relay with ReScript.",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "graphql",
+    "relay",
+    "relaymodern",
+    "react",
+    "reason",
+    "reasonml",
+    "rescript"
+  ],
+  "exports": {
+    "./src/utils": {
+      "require": "./src/utils.js",
+      "import": "./src/utils.mjs"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "rescript-relay-compiler": "compiler.js",
+    "rescript-relay-cli": "cli/cli.js"
+  },
+  "scripts": {
+    "build": "rescript",
+    "build:test": "./build-compiler-dev.sh && ./rescript-relay-compiler",
+    "postinstall": "node postinstall.js",
+    "test": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest",
+    "test:ci": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest --ci --runInBand"
+  },
+  "devDependencies": {
+    "@glennsl/rescript-fetch": "^0.2.0",
+    "@rescript/react": "0.12.2",
+    "@testing-library/jest-dom": "^5.16.3",
+    "@testing-library/react": "^13.0.0-alpha.6",
+    "graphql-query-test-mock": "^0.12.1",
+    "jest": "^27.2.4",
+    "nock": "^11.7.0",
+    "node-fetch": "^2.6.0",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "react-relay": "17.0.0",
+    "relay-runtime": "17.0.0",
+    "rescript": "11.1.1"
+  },
+  "peerDependencies": {
+    "@rescript/react": "^0.12.1",
+    "react-relay": "17.0.0",
+    "relay-runtime": "17.0.0",
+    "rescript": "^11.0.0"
+  },
+  "dependencies": {
+    "detect-libc": "^2.0.1"
+  }
+}

package/postinstall.js

@@ -0,0 +1,189 @@
+/**
+ * release-postinstall.js
+ *
+ * This script is bundled with the `npm` package and executed on release.
+ * Since we have a 'fat' NPM package (with all platform binaries bundled),
+ * this postinstall script extracts them and puts the current platform's
+ * bits in the right place.
+ */
+
+var path = require("path");
+var cp = require("child_process");
+var fs = require("fs");
+var { isNonGlibcLinux } = require("detect-libc");
+var platform = process.platform;
+
+function getRelayCompilerPlatformSuffix() {
+  if (process.platform === "win32") {
+    return "win-x64";
+  } else if (process.platform === "darwin" && process.arch === "x64") {
+    return "macos-x64";
+  } else if (process.platform === "darwin" && process.arch === "arm64") {
+    return "macos-arm64";
+  } else if (process.platform === "linux" && isNonGlibcLinux) {
+    return "linux-musl";
+  } else if (process.platform === "linux" && process.arch === "x64") {
+    return "linux-x64";
+  }
+
+  return "linux-x64";
+}
+
+/**
+ * Since os.arch returns node binary's target arch, not
+ * the system arch.
+ * Credits: https://github.com/feross/arch/blob/af080ff61346315559451715c5393d8e86a6d33c/index.js#L10-L58
+ */
+
+function ppxArch() {
+  if (platform === "darwin" && process.arch === "arm64") {
+    return "arm64";
+  }
+
+  /**
+   * The running binary is 64-bit, so the OS is clearly 64-bit.
+   */
+  if (process.arch === "x64") {
+    return "x64";
+  }
+
+  /**
+   * All recent versions of Mac OS are 64-bit.
+   */
+  if (process.platform === "darwin") {
+    return "x64";
+  }
+
+  /**
+   * On Windows, the most reliable way to detect a 64-bit OS from within a 32-bit
+   * app is based on the presence of a WOW64 file: %SystemRoot%\SysNative.
+   * See: https://twitter.com/feross/status/776949077208510464
+   */
+  if (process.platform === "win32") {
+    var useEnv = false;
+    try {
+      useEnv = !!(
+        process.env.SYSTEMROOT && fs.statSync(process.env.SYSTEMROOT)
+      );
+    } catch (err) {}
+
+    var sysRoot = useEnv ? process.env.SYSTEMROOT : "C:\\Windows";
+
+    // If %SystemRoot%\SysNative exists, we are in a WOW64 FS Redirected application.
+    var isWOW64 = false;
+    try {
+      isWOW64 = !!fs.statSync(path.join(sysRoot, "sysnative"));
+    } catch (err) {}
+
+    return isWOW64 ? "x64" : "x86";
+  }
+
+  /**
+   * On Linux, use the `getconf` command to get the architecture.
+   */
+  if (process.platform === "linux") {
+    var output = cp.execSync("getconf LONG_BIT", { encoding: "utf8" });
+    return output === "64\n" ? "x64" : "x86";
+  }
+
+  /**
+   * If none of the above, assume the architecture is 32-bit.
+   */
+  return "x86";
+}
+
+function copyPlatformBinaries(platform) {
+  /**
+   * Copy the PPX
+   */
+  const ppxFinalFilename = platform === "windows-latest" ? "ppx.exe" : "ppx";
+  const ppxFinalPath = path.join(__dirname, ppxFinalFilename);
+
+  if (!fs.existsSync(ppxFinalPath)) {
+    fs.copyFileSync(path.join(__dirname, "ppx-" + platform), ppxFinalPath);
+  }
+  fs.chmodSync(ppxFinalPath, 0o777);
+
+  /**
+   * Copy the Relay compiler
+   */
+
+  var platformSuffix = getRelayCompilerPlatformSuffix();
+
+  const rescriptRelayCompilerFinalPath = path.join(
+    __dirname,
+    "rescript-relay-compiler.exe"
+  );
+
+  if (!fs.existsSync(rescriptRelayCompilerFinalPath)) {
+    fs.copyFileSync(
+      path.join(
+        __dirname,
+        "relay-compiler-" + platformSuffix,
+        platformSuffix === "win-x64" ? "relay.exe" : "relay"
+      ),
+      rescriptRelayCompilerFinalPath
+    );
+  }
+  fs.chmodSync(rescriptRelayCompilerFinalPath, 0o777);
+}
+
+function unlinkIfNotExistsSync(path) {
+  if (fs.existsSync(path)) {
+    fs.unlinkSync(path);
+  }
+}
+
+function removeInitialBinaries() {
+  unlinkIfNotExistsSync(path.join(__dirname, "ppx-macos-arm64"));
+  unlinkIfNotExistsSync(path.join(__dirname, "ppx-macos-latest"));
+  unlinkIfNotExistsSync(path.join(__dirname, "ppx-windows-latest"));
+  unlinkIfNotExistsSync(path.join(__dirname, "ppx-linux"));
+  fs.rmSync(path.join(__dirname, "relay-compiler-linux-x64"), {
+    recursive: true,
+    force: true,
+  });
+  fs.rmSync(path.join(__dirname, "relay-compiler-macos-x64"), {
+    recursive: true,
+    force: true,
+  });
+  fs.rmSync(path.join(__dirname, "relay-compiler-macos-arm64"), {
+    recursive: true,
+    force: true,
+  });
+  fs.rmSync(path.join(__dirname, "relay-compiler-linux-musl"), {
+    recursive: true,
+    force: true,
+  });
+  fs.rmSync(path.join(__dirname, "relay-compiler-win-x64"), {
+    recursive: true,
+    force: true,
+  });
+}
+
+switch (platform) {
+  case "win32": {
+    if (ppxArch() !== "x64") {
+      console.warn("error: x86 is currently not supported on Windows");
+      process.exit(1);
+    }
+    copyPlatformBinaries("windows-latest");
+    break;
+  }
+  case "linux":
+    copyPlatformBinaries(platform);
+    break;
+  case "darwin": {
+    if (ppxArch() === "arm64") {
+      copyPlatformBinaries("macos-arm64");
+    } else {
+      copyPlatformBinaries("macos-latest");
+    }
+    break;
+  }
+  default:
+    console.warn("error: no release built for the " + platform + " platform");
+    process.exit(1);
+}
+
+removeInitialBinaries();

package/rescript.json

@@ -0,0 +1,19 @@
+{
+  "name": "rescript-relay",
+  "version": "0.1.0",
+  "namespace": false,
+  "sources": [
+    {
+      "dir": "src"
+    }
+  ],
+  "package-specs": {
+    "module": "commonjs",
+    "in-source": true
+  },
+  "bs-dependencies": ["@rescript/react"],
+  "suffix": ".bs.js",
+  "warnings": {
+    "error": "+101"
+  }
+}

package/src/ReactDOMExperimental.bs.js

@@ -0,0 +1,23 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var ReactDOM = require("@rescript/react/src/ReactDOM.bs.js");
+var Client = require("react-dom/client");
+
+function renderConcurrentRootAtElementWithId(content, id) {
+  var element = document.getElementById(id);
+  if (element == null) {
+    throw {
+          RE_EXN_ID: "Invalid_argument",
+          _1: "ReactExperimental.renderConcurrentRootAtElementWithId : no element of id " + id + " found in the HTML.",
+          Error: new Error()
+        };
+  }
+  Client.createRoot(element).render(content);
+}
+
+var Root = ReactDOM.Client.Root;
+
+exports.Root = Root;
+exports.renderConcurrentRootAtElementWithId = renderConcurrentRootAtElementWithId;
+/* react-dom/client Not a pure module */

package/src/ReactDOMExperimental.res

@@ -0,0 +1,16 @@
+include ReactDOM.Client
+
+@val @return(nullable)
+external getElementById: string => option<Dom.element> = "document.getElementById"
+
+let renderConcurrentRootAtElementWithId: (React.element, string) => unit = (content, id) =>
+  switch getElementById(id) {
+  | None =>
+    raise(
+      Invalid_argument(
+        "ReactExperimental.renderConcurrentRootAtElementWithId : no element of id " ++
+        id ++ " found in the HTML.",
+      ),
+    )
+  | Some(element) => createRoot(element)->Root.render(content)
+  }

package/src/ReactExperimental.bs.js

@@ -0,0 +1,23 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var React = require("react");
+
+function useTransition() {
+  var match = React.useTransition();
+  var startTransition = match[1];
+  return [
+          match[0],
+          React.useMemo((function () {
+                  return function (cb) {
+                    startTransition(cb, undefined);
+                  };
+                }), [startTransition])
+        ];
+}
+
+var SuspenseList = {};
+
+exports.useTransition = useTransition;
+exports.SuspenseList = SuspenseList;
+/* react Not a pure module */

package/src/ReactExperimental.res

@@ -0,0 +1,21 @@
+@module("react")
+external useDeferredValue: 'value => 'value = "useDeferredValue"
+
+@module("react")
+external useTransitionWithOptions: unit => (
+  bool,
+  (unit => unit, option<{"name": option<string>}>) => unit,
+) = "useTransition"
+
+let useTransition = () => {
+  let (isPending, startTransition) = useTransitionWithOptions()
+  (isPending, React.useMemo1(() => cb => startTransition(cb, None), [startTransition]))
+}
+
+module SuspenseList = {
+  @module("react") @react.component
+  external make: (
+    ~children: React.element,
+    ~revealOrder: [#forwards | #backwards | #together]=?,
+  ) => React.element = "SuspenseList"
+}

package/src/ReactExperimental.resi

@@ -0,0 +1,18 @@
+@module("react")
+external useDeferredValue: 'value => 'value = "useDeferredValue"
+
+@module("react")
+external useTransitionWithOptions: unit => (
+  bool,
+  (unit => unit, option<{"name": option<string>}>) => unit,
+) = "useTransition"
+
+let useTransition: unit => (bool, (unit => unit) => unit)
+
+module SuspenseList: {
+  @module("react") @react.component
+  external make: (
+    ~children: React.element,
+    ~revealOrder: [#forwards | #backwards | #together]=?,
+  ) => React.element = "SuspenseList"
+}