@shopify/hydrogen 0.0.0-experimental-20220526194818

package/vendor/react-server-dom-vite/cjs/react-server-dom-vite.production.min.js

@@ -0,0 +1,19 @@
+/**
+ * @license React
+ * react-server-dom-vite.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.
+ */
+'use strict';var g=require("react"),h={stream:!0},l={__INJECTED_CLIENT_IMPORTERS__:null};"undefined"!==typeof jest&&(global.allClientComponents=l);function m(a){var b=l[a];return b?"function"===typeof b?b():Promise.resolve(b):Promise.reject(Error("Could not find client component "+a))}var n=new Map;function p(a){function b(a){n.set(c,a);return a}var c=a.id;n.has(c)||(a=m(c),b(a),a.then(b,b))}var q=Symbol.for("react.element"),r=Symbol.for("react.lazy"),t=Symbol.for("react.default_value"),v=g.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ContextRegistry;
+function w(a){v[a]||(v[a]=g.createServerContext(a,t));return v[a]}function x(a,b,c){this._status=a;this._value=b;this._response=c}x.prototype.then=function(a){0===this._status?(null===this._value&&(this._value=[]),this._value.push(a)):a()};
+function y(a){switch(a._status){case 3:return a._value;case 1:var b=JSON.parse(a._value,a._response._fromJSON);a._status=3;return a._value=b;case 2:var c=a._value;b=c.name;c=n.get(c.id);if(!c||c instanceof Promise||c instanceof Error)throw c;b=c[b];a._status=3;return a._value=b;case 0:throw a;default:throw a._value;}}function z(){var a=A(this,0);return y(a)}function B(a,b){return new x(3,b,a)}function C(a){if(null!==a)for(var b=0;b<a.length;b++)(0,a[b])()}
+function D(a,b){if(0===a._status){var c=a._value;a._status=4;a._value=b;C(c)}}function E(a,b){a._chunks.forEach(function(a){D(a,b)})}function A(a,b){var c=a._chunks,d=c.get(b);d||(d=new x(0,null,a),c.set(b,d));return d}function F(a,b,c){switch(c[0]){case "$":if("$"===c)return q;if("$"===c[1]||"@"===c[1])return c.substring(1);b=parseInt(c.substring(1),16);a=A(a,b);return y(a);case "@":return b=parseInt(c.substring(1),16),a=A(a,b),{$$typeof:r,_payload:a,_init:y}}return c}
+function G(a){E(a,Error("Connection closed."))}
+function H(a,b){if(""!==b){var c=b[0],d=b.indexOf(":",1),e=parseInt(b.substring(1,d),16);b=b.substring(d+1);switch(c){case "J":d=a._chunks;(c=d.get(e))?0===c._status&&(a=c._value,c._status=1,c._value=b,C(a)):d.set(e,new x(1,b,a));break;case "M":d=a._chunks;c=d.get(e);b=JSON.parse(b,a._fromJSON);p(b);c?0===c._status&&(a=c._value,c._status=2,c._value=b,C(a)):d.set(e,new x(2,b,a));break;case "P":a._chunks.set(e,B(a,w(b).Provider));break;case "S":b=JSON.parse(b);a._chunks.set(e,B(a,Symbol.for(b)));break;
+case "E":c=JSON.parse(b);b=Error(c.message);b.stack=c.stack;c=a._chunks;(d=c.get(e))?D(d,b):c.set(e,new x(4,b,a));break;default:throw Error("Error parsing the data. It's probably an error code or network corruption.");}}}function I(a){return function(b,c){return"string"===typeof c?F(a,this,c):"object"===typeof c&&null!==c?(b=c[0]===q?{$$typeof:q,type:c[1],key:c[2],ref:null,props:c[3],_owner:null}:c,b):c}}
+function J(){var a=new TextDecoder;a={_chunks:new Map,readRoot:z,_partialRow:"",_stringDecoder:a};a._fromJSON=I(a);return a}function K(a,b){function c(b){var k=b.value;if(b.done)G(a);else{b=k;k=a._stringDecoder;for(var f=b.indexOf(10);-1<f;){var L=a._partialRow;var u=b.subarray(0,f);u=k.decode(u);H(a,L+u);a._partialRow="";b=b.subarray(f+1);f=b.indexOf(10)}a._partialRow+=k.decode(b,h);return e.read().then(c,d)}}function d(b){E(a,b)}var e=b.getReader();e.read().then(c,d)}
+exports.createFromFetch=function(a){var b=J();a.then(function(a){K(b,a.body)},function(a){E(b,a)});return b};exports.createFromReadableStream=function(a){var b=J();K(b,a);return b};
+exports.createFromXHR=function(a){function b(){for(var b=a.responseText,c=e,f=b.indexOf("\n",c);-1<f;)c=d._partialRow+b.substring(c,f),H(d,c),d._partialRow="",c=f+1,f=b.indexOf("\n",c);d._partialRow+=b.substring(c);e=b.length}function c(){E(d,new TypeError("Network error"))}var d=J(),e=0;a.addEventListener("progress",b);a.addEventListener("load",function(){b();G(d)});a.addEventListener("error",c);a.addEventListener("abort",c);a.addEventListener("timeout",c);return d};

package/vendor/react-server-dom-vite/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/vendor/react-server-dom-vite/esm/react-server-dom-vite-client-proxy.js

@@ -0,0 +1,88 @@
+/**
+* @license React
+ * react-server-dom-vite-client-proxy.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.
+ */
+
+import { useState } from 'react';
+
+// Store of components discovered during RSC to load
+// them later when consuming the response in SSR.
+globalThis.__COMPONENT_INDEX = {}; // Store to get module references for long strings
+// when rendering in RSC (strings cannot be wrapped Proxy).
+
+globalThis.__STRING_REFERENCE_INDEX = {};
+var MODULE_TAG = Symbol.for('react.module.reference');
+var STRING_SIZE_LIMIT = 64;
+var FN_RSC_ERROR = 'Functions exported from client components cannot be called or used as constructors from a server component.'; // TODO what's a better way to detect Flight runtime?
+
+function isRsc() {
+  try {
+    useState();
+    return false;
+  } catch (error) {
+    return error.message.endsWith('Server Components.');
+  }
+}
+
+function createModuleReference(id, value, name, isDefault) {
+  var moduleRef = Object.create(null);
+  moduleRef.$$typeof = MODULE_TAG;
+  moduleRef.filepath = id;
+  moduleRef.name = isDefault ? 'default' : name; // Store component in a global index during RSC to use it later in SSR
+
+  globalThis.__COMPONENT_INDEX[id] = Object.defineProperty(globalThis.__COMPONENT_INDEX[id] || Object.create(null), moduleRef.name, {
+    value: value,
+    writable: true
+  });
+  return moduleRef;
+} // A ClientProxy behaves as a module reference for the Flight
+// runtime (RSC) and as a real component for the Fizz runtime (SSR).
+// Note that this is not used in browser environments.
+
+
+function wrapInClientProxy(_ref) {
+  var id = _ref.id,
+      name = _ref.name,
+      isDefault = _ref.isDefault,
+      value = _ref.value;
+  var type = typeof value;
+
+  if (value === null || type !== 'object' && type !== 'function') {
+    if (type === 'string' && value.length >= STRING_SIZE_LIMIT) {
+      var _moduleRef = createModuleReference(id, value, name, isDefault);
+
+      globalThis.__STRING_REFERENCE_INDEX[value] = _moduleRef;
+    }
+
+    return value;
+  }
+
+  var moduleRef = createModuleReference(id, value, name, isDefault);
+
+  var get = function (target, prop, receiver) {
+    if (prop === '$$unwrappedValue') return value;
+    if (prop === '$$moduleReference') return moduleRef;
+    return Reflect.get(isRsc() ? moduleRef : target, prop, receiver);
+  };
+
+  return new Proxy(value, type === 'object' ? {
+    get: get
+  } : {
+    get: get,
+    apply: function () {
+      if (isRsc()) throw new Error(FN_RSC_ERROR + (" Calling \"" + name + "\"."));
+      return Reflect.apply.apply(Reflect, arguments);
+    },
+    construct: function () {
+      if (isRsc()) throw new Error(FN_RSC_ERROR + (" Instantiating \"" + name + "\"."));
+      return Reflect.construct.apply(Reflect, arguments);
+    }
+  });
+}
+
+export { FN_RSC_ERROR, MODULE_TAG, STRING_SIZE_LIMIT, isRsc, wrapInClientProxy };

package/vendor/react-server-dom-vite/esm/react-server-dom-vite-plugin.js

@@ -0,0 +1,352 @@
+/**
+* @license React
+ * react-server-dom-vite-plugin.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.
+ */
+
+import { init, parse } from 'es-module-lexer';
+import MagicString from 'magic-string';
+import { normalizePath, transformWithEsbuild } from 'vite';
+import { promises } from 'fs';
+import path from 'path';
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it;
+
+  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+
+      var F = function () {};
+
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  var normalCompletion = true,
+      didErr = false,
+      err;
+  return {
+    s: function () {
+      it = o[Symbol.iterator]();
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+var rscViteFileRE = /\/react-server-dom-vite.js/;
+var noProxyRE = /[&?]no-proxy($|&)/;
+function ReactFlightVitePlugin() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref$isServerComponen = _ref.isServerComponentImporterAllowed,
+      isServerComponentImporterAllowed = _ref$isServerComponen === void 0 ? function (importer) {
+    return false;
+  } : _ref$isServerComponen,
+      _ref$isClientComponen = _ref.isClientComponent,
+      isClientComponent = _ref$isClientComponen === void 0 ? function (id) {
+    return /\.client\.[jt]sx?($|\?)/.test(id);
+  } : _ref$isClientComponen,
+      findClientComponentsForClientBuild = _ref.findClientComponentsForClientBuild;
+
+  var config;
+  var server;
+  var invalidateTimeout;
+  var absoluteImporterPath;
+
+  function invalidateImporter() {
+    clearTimeout(invalidateTimeout);
+    invalidateTimeout = setTimeout(function () {
+      return server.watcher.emit('change', absoluteImporterPath);
+    }, 100);
+  }
+
+  function wrapIfClientComponent(id) {
+    var handle = function (isClient) {
+      if (!isClient) return null;
+
+      if (server) {
+        var moduleNode = server.moduleGraph.getModuleById(id);
+
+        if (!moduleNode.__isClientComponent) {
+          moduleNode.__isClientComponent = true;
+          if (absoluteImporterPath) invalidateImporter();
+        }
+      }
+
+      return proxyClientComponent(id.split('?')[0]);
+    };
+
+    var tmp = isClientComponent(id);
+    return typeof tmp === 'boolean' ? handle(tmp) : tmp.then(handle);
+  }
+
+  return {
+    name: 'vite-plugin-react-server-components',
+    enforce: 'pre',
+    configureServer: function (_server) {
+      server = _server;
+    },
+    configResolved: function (_config) {
+      config = _config; // By pushing this plugin at the end of the existing array,
+      // we enforce running it *after* Vite resolves import.meta.glob.
+
+      config.plugins.push(hashImportsPlugin);
+    },
+    resolveId: function (source, importer) {
+      if (!importer) return null;
+      /**
+       * Throw errors when non-Server Components try to load Server Components.
+       */
+
+      if (/\.server(\.[jt]sx?)?$/.test(source) && !(/(\.server\.[jt]sx?|index\.html)$/.test(importer) || isServerComponentImporterAllowed(importer, source))) {
+        throw new Error("Cannot import " + source + " from \"" + importer + "\". " + 'By react-server convention, .server.js files can only be imported from other .server.js files. ' + 'That way nobody accidentally sends these to the client by indirectly importing it.');
+      }
+    },
+    load: function (id) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!options.ssr || !shouldCheckClientComponent(id)) return;
+
+      if (server) {
+        var mod = server.moduleGraph.idToModuleMap.get(id.replace('/@fs', ''));
+
+        if (mod && mod.importers) {
+          if (Array.from(mod.importers).every(function (impMod) {
+            return noProxyRE.test(impMod.id);
+          })) {
+            // This module is only imported from client components
+            // so we don't need to create a module reference
+            return;
+          }
+        }
+      }
+
+      return wrapIfClientComponent(id);
+    },
+    transform: function (code, id) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+      /**
+       * In order to allow dynamic component imports from RSC, we use Vite's import.meta.glob.
+       * This hook replaces the glob placeholders with resolved paths to all client components.
+       *
+       * NOTE: Glob import paths MUST be relative to the importer file in
+       * order to get the `?v=xxx` querystring from Vite added to the import URL.
+       * If the paths are relative to the root instead, Vite won't add the querystring
+       * and we will have duplicated files in the browser (with duplicated contexts, etc).
+       */
+      if (rscViteFileRE.test(id)) {
+        var INJECTING_RE = /\{\s*__INJECTED_CLIENT_IMPORTERS__[:\s]*null[,\s]*\}\s*;/;
+        var s = new MagicString(code);
+        id = id.split('?')[0];
+
+        if (options && options.ssr) {
+          // In SSR, directly use components already discovered by RSC
+          // instead of globs to avoid bundling unused components.
+          s.replace(INJECTING_RE, 'globalThis.__COMPONENT_INDEX');
+          return {
+            code: s.toString(),
+            map: s.generateMap({
+              file: id,
+              source: id
+            })
+          };
+        }
+
+        var injectGlobs = function (clientComponents) {
+          var importerPath = path.dirname(id);
+          var importers = clientComponents.map(function (absolutePath) {
+            return normalizePath(path.relative(importerPath, absolutePath));
+          });
+          var injectedGlobs = "Object.assign(Object.create(null), " + importers.map(function (glob) {
+            return (// Mark the globs to modify the result after Vite resolves them.
+              "/* HASH_BEGIN */ " + ("import.meta.glob('" + normalizePath(glob) + "') /* HASH_END */")
+            );
+          }).join(', ') + ");";
+          s.replace(INJECTING_RE, injectedGlobs);
+          return {
+            code: s.toString(),
+            map: s.generateMap({
+              file: id,
+              source: id
+            })
+          };
+        };
+
+        if (config.command === 'serve') {
+          absoluteImporterPath = id;
+          return injectGlobs(findClientComponentsForDev(server));
+        }
+
+        if (!findClientComponentsForClientBuild) {
+          throw new Error('[react-server-dom-vite] Parameter findClientComponentsForClientBuild is required for client build');
+        }
+
+        var tmp = findClientComponentsForClientBuild(config);
+        return Array.isArray(tmp) ? injectGlobs(tmp) : tmp.then(injectGlobs);
+      }
+    }
+  };
+}
+
+var btoa = function (hash) {
+  return (// eslint-disable-next-line react-internal/safe-string-coercion
+    Buffer.from(String(hash), 'binary').toString('base64')
+  );
+}; // Quick, lossy hash function: https://stackoverflow.com/a/8831937/4468962
+// Prevents leaking path information in the browser, and minifies RSC responses.
+
+
+function hashCode(value) {
+  var hash = 0;
+
+  for (var i = 0; i < value.length; i++) {
+    var char = value.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash &= hash;
+  }
+
+  return btoa(hash).replace(/=+/, '');
+}
+
+var getComponentFilename = function (filepath) {
+  return filepath.split('/').pop().split('.').shift();
+};
+
+var getComponentId = function (filepath) {
+  return getComponentFilename(filepath) + "-" + hashCode(filepath);
+};
+async function proxyClientComponent(filepath, src) {
+  var DEFAULT_EXPORT = 'default'; // Modify the import ID to avoid infinite wraps
+
+  var importFrom = filepath + "?no-proxy";
+  await init;
+
+  if (!src) {
+    src = await promises.readFile(filepath, 'utf-8');
+  }
+
+  var _await$transformWithE = await transformWithEsbuild(src, filepath),
+      code = _await$transformWithE.code;
+
+  var _parse = parse(code),
+      exportStatements = _parse[1];
+
+  var proxyCode = "import {wrapInClientProxy} from 'react-server-dom-vite/client-proxy';\n" + ("import * as allImports from '" + importFrom + "';\n\n"); // Wrap components in Client Proxy
+
+  exportStatements.forEach(function (key) {
+    var isDefault = key === DEFAULT_EXPORT;
+    var componentName = isDefault ? getComponentFilename(filepath) : key;
+    proxyCode += "export " + (isDefault ? DEFAULT_EXPORT : "const " + componentName + " =") + " wrapInClientProxy({ name: '" + componentName + "', id: '" + getComponentId(filepath) + "', value: allImports['" + key + "'], isDefault: " + // eslint-disable-next-line react-internal/safe-string-coercion
+    String(isDefault) + " });\n";
+  });
+  return proxyCode;
+}
+
+function shouldCheckClientComponent(id) {
+  return /\.[jt]sx?($|\?)/.test(id) && !noProxyRE.test(id);
+}
+
+function findClientComponentsForDev(server) {
+  var clientComponents = []; // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+
+  var _iterator = _createForOfIteratorHelper(server.moduleGraph.fileToModulesMap.values()),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var set = _step.value;
+      var clientModule = Array.from(set).find(function (moduleNode) {
+        return moduleNode.__isClientComponent;
+      });
+      if (clientModule) clientComponents.push(clientModule.file);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return clientComponents;
+}
+
+var hashImportsPlugin = {
+  name: 'vite-plugin-react-server-components-hash-imports',
+  enforce: 'post',
+  transform: function (code, id) {
+    // Turn relative import paths to lossy hashes
+    if (rscViteFileRE.test(id)) {
+      var s = new MagicString(code);
+      s.replace(/\/\*\s*HASH_BEGIN\s*\*\/\s*([^]+?)\/\*\s*HASH_END\s*\*\//gm, function (_, imports) {
+        return imports.trim().replace(/"([^"]+?)":/gm, function (__, relativePath) {
+          var absolutePath = path.resolve(path.dirname(id.split('?')[0]), relativePath);
+          return "\"" + getComponentId(normalizePath(absolutePath)) + "\":";
+        });
+      });
+      return {
+        code: s.toString(),
+        map: s.generateMap({
+          file: id,
+          source: id
+        })
+      };
+    }
+  }
+}; // This can be used in custom findClientComponentsForClientBuild implementations
+
+ReactFlightVitePlugin.findClientComponentsFromServer = findClientComponentsForDev;
+
+export default ReactFlightVitePlugin;