@clary-so/measure 0.4.4 → 0.4.6

package/dist/react-bundled.js

@@ -0,0 +1,305 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// ../../../node_modules/react/cjs/react.production.min.js
+var require_react_production_min = __commonJS({
+  "../../../node_modules/react/cjs/react.production.min.js"(exports2) {
+    "use strict";
+    var l = /* @__PURE__ */ Symbol.for("react.element");
+    var n = /* @__PURE__ */ Symbol.for("react.portal");
+    var p = /* @__PURE__ */ Symbol.for("react.fragment");
+    var q = /* @__PURE__ */ Symbol.for("react.strict_mode");
+    var r = /* @__PURE__ */ Symbol.for("react.profiler");
+    var t = /* @__PURE__ */ Symbol.for("react.provider");
+    var u = /* @__PURE__ */ Symbol.for("react.context");
+    var v = /* @__PURE__ */ Symbol.for("react.forward_ref");
+    var w = /* @__PURE__ */ Symbol.for("react.suspense");
+    var x = /* @__PURE__ */ Symbol.for("react.memo");
+    var y = /* @__PURE__ */ Symbol.for("react.lazy");
+    var z = Symbol.iterator;
+    function A(a) {
+      if (null === a || "object" !== typeof a) return null;
+      a = z && a[z] || a["@@iterator"];
+      return "function" === typeof a ? a : null;
+    }
+    var B = { isMounted: function() {
+      return false;
+    }, enqueueForceUpdate: function() {
+    }, enqueueReplaceState: function() {
+    }, enqueueSetState: function() {
+    } };
+    var C = Object.assign;
+    var D = {};
+    function E(a, b, e) {
+      this.props = a;
+      this.context = b;
+      this.refs = D;
+      this.updater = e || B;
+    }
+    E.prototype.isReactComponent = {};
+    E.prototype.setState = function(a, b) {
+      if ("object" !== typeof a && "function" !== typeof a && null != a) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+      this.updater.enqueueSetState(this, a, b, "setState");
+    };
+    E.prototype.forceUpdate = function(a) {
+      this.updater.enqueueForceUpdate(this, a, "forceUpdate");
+    };
+    function F() {
+    }
+    F.prototype = E.prototype;
+    function G(a, b, e) {
+      this.props = a;
+      this.context = b;
+      this.refs = D;
+      this.updater = e || B;
+    }
+    var H = G.prototype = new F();
+    H.constructor = G;
+    C(H, E.prototype);
+    H.isPureReactComponent = true;
+    var I = Array.isArray;
+    var J = Object.prototype.hasOwnProperty;
+    var K = { current: null };
+    var L = { key: true, ref: true, __self: true, __source: true };
+    function M(a, b, e) {
+      var d, c = {}, k = null, h = null;
+      if (null != b) for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b) J.call(b, d) && !L.hasOwnProperty(d) && (c[d] = b[d]);
+      var g = arguments.length - 2;
+      if (1 === g) c.children = e;
+      else if (1 < g) {
+        for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];
+        c.children = f;
+      }
+      if (a && a.defaultProps) for (d in g = a.defaultProps, g) void 0 === c[d] && (c[d] = g[d]);
+      return { $$typeof: l, type: a, key: k, ref: h, props: c, _owner: K.current };
+    }
+    function N(a, b) {
+      return { $$typeof: l, type: a.type, key: b, ref: a.ref, props: a.props, _owner: a._owner };
+    }
+    function O(a) {
+      return "object" === typeof a && null !== a && a.$$typeof === l;
+    }
+    function escape(a) {
+      var b = { "=": "=0", ":": "=2" };
+      return "$" + a.replace(/[=:]/g, function(a2) {
+        return b[a2];
+      });
+    }
+    var P = /\/+/g;
+    function Q(a, b) {
+      return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
+    }
+    function R(a, b, e, d, c) {
+      var k = typeof a;
+      if ("undefined" === k || "boolean" === k) a = null;
+      var h = false;
+      if (null === a) h = true;
+      else switch (k) {
+        case "string":
+        case "number":
+          h = true;
+          break;
+        case "object":
+          switch (a.$$typeof) {
+            case l:
+            case n:
+              h = true;
+          }
+      }
+      if (h) return h = a, c = c(h), a = "" === d ? "." + Q(h, 0) : d, I(c) ? (e = "", null != a && (e = a.replace(P, "$&/") + "/"), R(c, b, e, "", function(a2) {
+        return a2;
+      })) : null != c && (O(c) && (c = N(c, e + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(P, "$&/") + "/") + a)), b.push(c)), 1;
+      h = 0;
+      d = "" === d ? "." : d + ":";
+      if (I(a)) for (var g = 0; g < a.length; g++) {
+        k = a[g];
+        var f = d + Q(k, g);
+        h += R(k, b, e, f, c);
+      }
+      else if (f = A(a), "function" === typeof f) for (a = f.call(a), g = 0; !(k = a.next()).done; ) k = k.value, f = d + Q(k, g++), h += R(k, b, e, f, c);
+      else if ("object" === k) throw b = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
+      return h;
+    }
+    function S(a, b, e) {
+      if (null == a) return a;
+      var d = [], c = 0;
+      R(a, d, "", "", function(a2) {
+        return b.call(e, a2, c++);
+      });
+      return d;
+    }
+    function T(a) {
+      if (-1 === a._status) {
+        var b = a._result;
+        b = b();
+        b.then(function(b2) {
+          if (0 === a._status || -1 === a._status) a._status = 1, a._result = b2;
+        }, function(b2) {
+          if (0 === a._status || -1 === a._status) a._status = 2, a._result = b2;
+        });
+        -1 === a._status && (a._status = 0, a._result = b);
+      }
+      if (1 === a._status) return a._result.default;
+      throw a._result;
+    }
+    var U = { current: null };
+    var V = { transition: null };
+    var W = { ReactCurrentDispatcher: U, ReactCurrentBatchConfig: V, ReactCurrentOwner: K };
+    function X() {
+      throw Error("act(...) is not supported in production builds of React.");
+    }
+    exports2.Children = { map: S, forEach: function(a, b, e) {
+      S(a, function() {
+        b.apply(this, arguments);
+      }, e);
+    }, count: function(a) {
+      var b = 0;
+      S(a, function() {
+        b++;
+      });
+      return b;
+    }, toArray: function(a) {
+      return S(a, function(a2) {
+        return a2;
+      }) || [];
+    }, only: function(a) {
+      if (!O(a)) throw Error("React.Children.only expected to receive a single React element child.");
+      return a;
+    } };
+    exports2.Component = E;
+    exports2.Fragment = p;
+    exports2.Profiler = r;
+    exports2.PureComponent = G;
+    exports2.StrictMode = q;
+    exports2.Suspense = w;
+    exports2.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
+    exports2.act = X;
+    exports2.cloneElement = function(a, b, e) {
+      if (null === a || void 0 === a) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + ".");
+      var d = C({}, a.props), c = a.key, k = a.ref, h = a._owner;
+      if (null != b) {
+        void 0 !== b.ref && (k = b.ref, h = K.current);
+        void 0 !== b.key && (c = "" + b.key);
+        if (a.type && a.type.defaultProps) var g = a.type.defaultProps;
+        for (f in b) J.call(b, f) && !L.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
+      }
+      var f = arguments.length - 2;
+      if (1 === f) d.children = e;
+      else if (1 < f) {
+        g = Array(f);
+        for (var m = 0; m < f; m++) g[m] = arguments[m + 2];
+        d.children = g;
+      }
+      return { $$typeof: l, type: a.type, key: c, ref: k, props: d, _owner: h };
+    };
+    exports2.createContext = function(a) {
+      a = { $$typeof: u, _currentValue: a, _currentValue2: a, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null };
+      a.Provider = { $$typeof: t, _context: a };
+      return a.Consumer = a;
+    };
+    exports2.createElement = M;
+    exports2.createFactory = function(a) {
+      var b = M.bind(null, a);
+      b.type = a;
+      return b;
+    };
+    exports2.createRef = function() {
+      return { current: null };
+    };
+    exports2.forwardRef = function(a) {
+      return { $$typeof: v, render: a };
+    };
+    exports2.isValidElement = O;
+    exports2.lazy = function(a) {
+      return { $$typeof: y, _payload: { _status: -1, _result: a }, _init: T };
+    };
+    exports2.memo = function(a, b) {
+      return { $$typeof: x, type: a, compare: void 0 === b ? null : b };
+    };
+    exports2.startTransition = function(a) {
+      var b = V.transition;
+      V.transition = {};
+      try {
+        a();
+      } finally {
+        V.transition = b;
+      }
+    };
+    exports2.unstable_act = X;
+    exports2.useCallback = function(a, b) {
+      return U.current.useCallback(a, b);
+    };
+    exports2.useContext = function(a) {
+      return U.current.useContext(a);
+    };
+    exports2.useDebugValue = function() {
+    };
+    exports2.useDeferredValue = function(a) {
+      return U.current.useDeferredValue(a);
+    };
+    exports2.useEffect = function(a, b) {
+      return U.current.useEffect(a, b);
+    };
+    exports2.useId = function() {
+      return U.current.useId();
+    };
+    exports2.useImperativeHandle = function(a, b, e) {
+      return U.current.useImperativeHandle(a, b, e);
+    };
+    exports2.useInsertionEffect = function(a, b) {
+      return U.current.useInsertionEffect(a, b);
+    };
+    exports2.useLayoutEffect = function(a, b) {
+      return U.current.useLayoutEffect(a, b);
+    };
+    exports2.useMemo = function(a, b) {
+      return U.current.useMemo(a, b);
+    };
+    exports2.useReducer = function(a, b, e) {
+      return U.current.useReducer(a, b, e);
+    };
+    exports2.useRef = function(a) {
+      return U.current.useRef(a);
+    };
+    exports2.useState = function(a) {
+      return U.current.useState(a);
+    };
+    exports2.useSyncExternalStore = function(a, b, e) {
+      return U.current.useSyncExternalStore(a, b, e);
+    };
+    exports2.useTransition = function() {
+      return U.current.useTransition();
+    };
+    exports2.version = "18.3.1";
+  }
+});
+
+// ../../../node_modules/react/index.js
+var require_react = __commonJS({
+  "../../../node_modules/react/index.js"(exports2, module2) {
+    "use strict";
+    if (true) {
+      module2.exports = require_react_production_min();
+    } else {
+      module2.exports = null;
+    }
+  }
+});
+
+// <stdin>
+module.exports = require_react();
+/*! Bundled license information:
+
+react/cjs/react.production.min.js:
+  (**
+   * @license React
+   * react.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+*/

package/esbuild-bin.mjs

@@ -1,26 +1,44 @@
 import * as esbuild from "esbuild";
+import { writeFileSync } from "fs";
 
+// Step 1: Bundle just React into its own file
 await esbuild.build({
   absWorkingDir: new URL(".", import.meta.url).pathname,
-  entryPoints: ["dist/server/bin.js"],
+  stdin: {
+    contents: `module.exports = require("react");`,
+    resolveDir: ".",
+  },
   bundle: true,
   platform: "node",
   target: "node18",
-  outfile: "dist/bin-bundled.js",
-  banner: { js: "#!/usr/bin/env node" },
-  // Bundle react, ink, and react-reconciler so they share one instance
-  // Keep other node_modules as external (express, socket.io, etc.)
-  external: [
-    "express",
-    "cors",
-    "socket.io",
-    "commander",
-    "@clary-so/*",
-    "yoga-wasm-web",
-  ],
+  outfile: "dist/react-bundled.js",
   define: {
     "process.env.NODE_ENV": '"production"',
   },
 });
 
-console.log("Bundled bin-bundled.js");
+// Step 2: Create a wrapper that patches require('react') to use our bundled copy,
+// then runs the original bin
+const wrapper = `#!/usr/bin/env node
+"use strict";
+const path = require("path");
+const Module = require("module");
+
+// Load our single bundled React instance
+const bundledReact = require(path.join(__dirname, "react-bundled.js"));
+
+// Patch require so all packages resolve to the same React instance
+const origResolve = Module._resolveFilename;
+Module._resolveFilename = function(request, parent, ...args) {
+  if (request === "react") {
+    return path.join(__dirname, "react-bundled.js");
+  }
+  return origResolve.call(this, request, parent, ...args);
+};
+
+// Now load the actual bin
+require("./server/bin.js");
+`;
+
+writeFileSync(new URL("dist/bin-bundled.js", import.meta.url), wrapper);
+console.log("Created bin-bundled.js wrapper");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clary-so/measure",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "author": {
     "name": "Almouro",
     "email": "alexandrem@bam.tech"